NoahSnowRoughness
Surface roughness over a snow pack in WRF's unified Noah land-surface model, SUBROUTINE SNOWZ0 of phys/module_sf_noahlsm.F (WRF 4.8, sf_surface_physics = 2): how burying the vegetation under snow smooths the surface the atmosphere sees. THE PHYSICS. Roughness elements are treated as seven roughness lengths tall, so the height still standing proud of the snow is 7 z0brd - snowh. While any of it shows, the snow-covered fraction's roughness is that exposed height divided back by seven -- a linear collapse from z0brd towards zero as the pack deepens -- and once it falls below snow_z0_burial_min the surface is taken as bare snow at snow_z0 = 1 mm. The total is the cover-weighted average of the snow-free background and that value. Note that it averages LENGTHS, not their logarithms, which is not what a flux-matching argument would give; WRF's own commented-out alternative one line above makes the same arithmetic average with the bare snow roughness in place of the interpolated one, so the choice is between two arithmetic averages rather than between an arithmetic and a geometric one. IT NEEDED NO INSTRUMENTATION. Its output is the Registry variable Z0, which the kernel driver already dumps as `z0_out`, and it is computed before SNOPAC so nothing later moves it. Supplied the three arguments the routine actually reads, the component reproduces `z0_out` BITWISE at all 84 steps of the cold-season set -- the 67 with snow cover and the 17 without. TWO OF THOSE THREE ARGUMENTS ARE NOT THE OBVIOUS ONES, and both were settled by measurement rather than by reading. `z0brd` must be REDPRM's greenness-selected value and not the argument a caller passes to SFLX (FORTRAN_BUGS N96, whose list of affected quantities this extends to a fourth): the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. And `snowh` is the CURRENT depth, after SNOW_NEW, despite SFLX's comment above the call claiming the previous time step's -- feeding the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. That the discrepancy is small here is an accident of this surface: z0brd = 0.15 m puts the burial height at 1.05 m against a pack never deeper than 0.31 m, so the snow depth barely moves z0eff. On a smoother surface it would not be small. REFERENCE STEP. Unlike `snow_new.esm` and `snow_compaction.esm` next door, this routine has NO step dependence of its own -- it is four lines of algebra on the current state, with no dt in it and nothing differenced -- so the choice of replay pass cannot change its accuracy, only which state it is asked about. The 1e-6 s pass is used because it is the one where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack disappears DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm`, which supplies that input in an assembly, is referenced against. NOT TRANSCRIBED: the entire UA_PHYS branch, which replaces the whole calculation with a logarithmic blend over buried canopy, ground and snow roughnesses; it is off in every reference run.
Description
Surface roughness over a snow pack in WRF’s unified Noah land-surface model, SUBROUTINE SNOWZ0 of phys/module_sf_noahlsm.F (WRF 4.8, sf_surface_physics = 2): how burying the vegetation under snow smooths the surface the atmosphere sees. THE PHYSICS. Roughness elements are treated as seven roughness lengths tall, so the height still standing proud of the snow is 7 z0brd - snowh. While any of it shows, the snow-covered fraction’s roughness is that exposed height divided back by seven – a linear collapse from z0brd towards zero as the pack deepens – and once it falls below snow_z0_burial_min the surface is taken as bare snow at snow_z0 = 1 mm. The total is the cover-weighted average of the snow-free background and that value. Note that it averages LENGTHS, not their logarithms, which is not what a flux-matching argument would give; WRF’s own commented-out alternative one line above makes the same arithmetic average with the bare snow roughness in place of the interpolated one, so the choice is between two arithmetic averages rather than between an arithmetic and a geometric one. IT NEEDED NO INSTRUMENTATION. Its output is the Registry variable Z0, which the kernel driver already dumps as z0_out, and it is computed before SNOPAC so nothing later moves it. Supplied the three arguments the routine actually reads, the component reproduces z0_out BITWISE at all 84 steps of the cold-season set – the 67 with snow cover and the 17 without. TWO OF THOSE THREE ARGUMENTS ARE NOT THE OBVIOUS ONES, and both were settled by measurement rather than by reading. z0brd must be REDPRM’s greenness-selected value and not the argument a caller passes to SFLX (FORTRAN_BUGS N96, whose list of affected quantities this extends to a fourth): the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. And snowh is the CURRENT depth, after SNOW_NEW, despite SFLX’s comment above the call claiming the previous time step’s – feeding the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. That the discrepancy is small here is an accident of this surface: z0brd = 0.15 m puts the burial height at 1.05 m against a pack never deeper than 0.31 m, so the snow depth barely moves z0eff. On a smoother surface it would not be small. REFERENCE STEP. Unlike snow_new.esm and snow_compaction.esm next door, this routine has NO step dependence of its own – it is four lines of algebra on the current state, with no dt in it and nothing differenced – so the choice of replay pass cannot change its accuracy, only which state it is asked about. The 1e-6 s pass is used because it is the one where the snow-cover input is unambiguous: at the 60 s pass, case D step 553’s pack disappears DURING the step and SNOPAC zeroes sncovr afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass snow_cover.esm, which supplies that input in an assembly, is referenced against. NOT TRANSCRIBED: the entire UA_PHYS branch, which replaces the whole calculation with a logarithmic blend over buried canopy, ground and snow roughnesses; it is off in every reference run.
Reference
- Livneh, B., Xia, Y., Mitchell, K. E., Ek, M. B., & Lettenmaier, D. P. (2010). Noah LSM snow model diagnostics and enhancements. J. Hydrometeorology, 11, 721-738.
- Ek, M. B., et al. (2003). Implementation of Noah land surface model advances in the NCEP operational mesoscale Eta model. J. Geophys. Res., 108(D22), 8851.
- wrf-model/WRF v4.8.0 phys/module_sf_noahlsm.F SUBROUTINE SNOWZ0 lines 3552-3598, called from SFLX at line 671 (cold-season reference run instrumented in ctessum-claude/WRF branch earthsciml-instrumented-noahcold).
Parameters
| Name | Units | Default | Description |
|---|---|---|---|
sncovr | 1 | 0.5 | Fractional snow cover, from the snow-cover component (SNFRAC and the 0.98 cap SFLX applies after it). It is the CURRENT step’s cover, formed after this step’s snowfall has been added to the pack. |
z0brd | m | 0.15 | Background (snow-free) roughness length of the surface. MUST be REDPRM’s greenness-selected value, not the ALBBCK-style argument a caller passes to SFLX: REDPRM overwrites Z0BRD from the vegetation type’s Z0MIN/Z0MAX before anything reads it, so a dump of the ARGUMENT records a value the scheme never applies. FORTRAN_BUGS N96, and this is the fourth quantity it catches – in the cold-season set the dumped argument takes 0.05 at some steps while the value SNOWZ0 uses is 0.150000006 at every one of them. soil_veg_parameters.esm computes the right one. |
snowh | m | 0.1 | Physical depth of the pack. This is the CURRENT depth, after SNOW_NEW has added this step’s snowfall – NOT the previous step’s, despite SFLX’s comment above the call reading ‘DETERMINE SURFACE ROUGHNESS OVER SNOWPACK USING SNOW CONDITION FROM THE PREVIOUS TIMESTEP’. SFLX calls SNOW_NEW and SNFRAC well before SNOWZ0, so both of this routine’s snow arguments are current. Measured on the cold-season set: feeding the previous step’s depth instead reproduces WRF to only 7.1e-12 relative, against BITWISE agreement with the current one. |
Observed
| Name | Units | Default | Description |
|---|---|---|---|
burial | m | How much of the vegetation is still standing proud of the snow, snow_z0_burial_factor z0brd - snowh: roughness elements are treated as seven roughness lengths tall, so this is their exposed height. It goes to zero as the pack buries them. | |
fully_buried | 1 | Indicator, 1 where the exposed height has fallen to snow_z0_burial_min and the surface is treated as bare snow. UNTESTED, not merely unused: burying this vegetation needs 1.05 m of snow (z0brd = 0.15 m) and the deepest pack in the cold-season set is 0.31 m, so all 67 snow-covered steps take the interpolating branch. It is the branch that would matter on a smooth surface, where 7 z0brd is comparable to the snow depth. | |
z0eff | m | Roughness the SNOW-COVERED fraction contributes: the exposed height divided back by the burial factor while the vegetation still shows, and the bare snow roughness once it does not. It falls linearly from z0brd at zero snow towards snow_z0 as the pack deepens. | |
z0 | m | Total roughness length, the cover-weighted average of the snow-free background and the snow-covered value. NOTE that this is an average of LENGTHS, not of their logarithms, which is what a flux-matching argument would give; WRF’s commented-out alternative one line above is the same arithmetic average with z0eff replaced by the bare snow value. At sncovr = 0 it reduces EXACTLY to z0brd, so SFLX’s IF (SNCOVR > 0) ... ELSE Z0 = Z0BRD guard is an optimisation rather than a semantic branch on this path, and this component is safe to mount unconditionally – unlike snow_new.esm, whose guard is load-bearing. | |
snow_present | 1 | Indicator for the caller’s guard, 1 where there is any snow cover. Reported so a consumer can see which branch SFLX would have taken; it does not gate anything here, for the reason given under z0. |
Observed expressions
$$ burial = par.snow_{z0\,burial\,factor} \cdot z0brd - snowh $$How much of the vegetation is still standing proud of the snow, snow_z0_burial_factor z0brd - snowh: roughness elements are treated as seven roughness lengths tall, so this is their exposed height. It goes to zero as the pack buries them.
$$ fully_{buried} = \mathrm{ifelse}\left(\mathrm{<=}\left(burial, par.snow_{z0\,burial\,min}\right), 1.0, 0.0\right) $$Indicator, 1 where the exposed height has fallen to snow_z0_burial_min and the surface is treated as bare snow. UNTESTED, not merely unused: burying this vegetation needs 1.05 m of snow (z0brd = 0.15 m) and the deepest pack in the cold-season set is 0.31 m, so all 67 snow-covered steps take the interpolating branch. It is the branch that would matter on a smooth surface, where 7 z0brd is comparable to the snow depth.
$$ z0eff = \mathrm{ifelse}\left(fully_{buried} = 1.0, par.snow_{z0}, \frac{burial}{par.snow_{z0\,burial\,factor}}\right) $$Roughness the SNOW-COVERED fraction contributes: the exposed height divided back by the burial factor while the vegetation still shows, and the bare snow roughness once it does not. It falls linearly from z0brd at zero snow towards snow_z0 as the pack deepens.
$$ z0 = \left(1.0 - sncovr\right) \cdot z0brd + sncovr \cdot z0eff $$Total roughness length, the cover-weighted average of the snow-free background and the snow-covered value. NOTE that this is an average of LENGTHS, not of their logarithms, which is what a flux-matching argument would give; WRF’s commented-out alternative one line above is the same arithmetic average with z0eff replaced by the bare snow value. At sncovr = 0 it reduces EXACTLY to z0brd, so SFLX’s IF (SNCOVR > 0) ... ELSE Z0 = Z0BRD guard is an optimisation rather than a semantic branch on this path, and this component is safe to mount unconditionally – unlike snow_new.esm, whose guard is load-bearing.
Indicator for the caller’s guard, 1 where there is any snow cover. Reported so a consumer can see which branch SFLX would have taken; it does not gate anything here, for the reason given under z0.
Raw .esm
Raw .esm JSON (this component)
{
"subsystems": {
"par": {
"ref": "./noah_parameters.esm"
}
},
"variables": {
"sncovr": {
"type": "parameter",
"units": "1",
"default": 0.5,
"description": "Fractional snow cover, from the snow-cover component (SNFRAC and the 0.98 cap SFLX applies after it). It is the CURRENT step's cover, formed after this step's snowfall has been added to the pack."
},
"z0brd": {
"type": "parameter",
"units": "m",
"default": 0.15,
"description": "Background (snow-free) roughness length of the surface. MUST be REDPRM's greenness-selected value, not the ALBBCK-style argument a caller passes to SFLX: REDPRM overwrites Z0BRD from the vegetation type's Z0MIN/Z0MAX before anything reads it, so a dump of the ARGUMENT records a value the scheme never applies. FORTRAN_BUGS N96, and this is the fourth quantity it catches -- in the cold-season set the dumped argument takes 0.05 at some steps while the value SNOWZ0 uses is 0.150000006 at every one of them. `soil_veg_parameters.esm` computes the right one."
},
"snowh": {
"type": "parameter",
"units": "m",
"default": 0.1,
"description": "Physical depth of the pack. This is the CURRENT depth, after SNOW_NEW has added this step's snowfall -- NOT the previous step's, despite SFLX's comment above the call reading 'DETERMINE SURFACE ROUGHNESS OVER SNOWPACK USING SNOW CONDITION FROM THE PREVIOUS TIMESTEP'. SFLX calls SNOW_NEW and SNFRAC well before SNOWZ0, so both of this routine's snow arguments are current. Measured on the cold-season set: feeding the previous step's depth instead reproduces WRF to only 7.1e-12 relative, against BITWISE agreement with the current one."
},
"burial": {
"type": "unknown",
"units": "m",
"description": "How much of the vegetation is still standing proud of the snow, snow_z0_burial_factor z0brd - snowh: roughness elements are treated as seven roughness lengths tall, so this is their exposed height. It goes to zero as the pack buries them."
},
"fully_buried": {
"type": "unknown",
"units": "1",
"description": "Indicator, 1 where the exposed height has fallen to snow_z0_burial_min and the surface is treated as bare snow. UNTESTED, not merely unused: burying this vegetation needs 1.05 m of snow (z0brd = 0.15 m) and the deepest pack in the cold-season set is 0.31 m, so all 67 snow-covered steps take the interpolating branch. It is the branch that would matter on a smooth surface, where 7 z0brd is comparable to the snow depth."
},
"z0eff": {
"type": "unknown",
"units": "m",
"description": "Roughness the SNOW-COVERED fraction contributes: the exposed height divided back by the burial factor while the vegetation still shows, and the bare snow roughness once it does not. It falls linearly from z0brd at zero snow towards snow_z0 as the pack deepens."
},
"z0": {
"type": "unknown",
"units": "m",
"description": "Total roughness length, the cover-weighted average of the snow-free background and the snow-covered value. NOTE that this is an average of LENGTHS, not of their logarithms, which is what a flux-matching argument would give; WRF's commented-out alternative one line above is the same arithmetic average with z0eff replaced by the bare snow value. At sncovr = 0 it reduces EXACTLY to z0brd, so SFLX's `IF (SNCOVR > 0) ... ELSE Z0 = Z0BRD` guard is an optimisation rather than a semantic branch on this path, and this component is safe to mount unconditionally -- unlike `snow_new.esm`, whose guard is load-bearing."
},
"snow_present": {
"type": "unknown",
"units": "1",
"description": "Indicator for the caller's guard, 1 where there is any snow cover. Reported so a consumer can see which branch SFLX would have taken; it does not gate anything here, for the reason given under z0."
}
},
"equations": [
{
"lhs": "burial",
"rhs": {
"op": "-",
"args": [
{
"op": "*",
"args": [
"par.snow_z0_burial_factor",
"z0brd"
]
},
"snowh"
]
}
},
{
"lhs": "fully_buried",
"rhs": {
"op": "ifelse",
"args": [
{
"op": "<=",
"args": [
"burial",
"par.snow_z0_burial_min"
]
},
1.0,
0.0
]
}
},
{
"lhs": "z0eff",
"rhs": {
"op": "ifelse",
"args": [
{
"op": "==",
"args": [
"fully_buried",
1.0
]
},
"par.snow_z0",
{
"op": "/",
"args": [
"burial",
"par.snow_z0_burial_factor"
]
}
]
}
},
{
"lhs": "z0",
"rhs": {
"op": "+",
"args": [
{
"op": "*",
"args": [
{
"op": "-",
"args": [
1.0,
"sncovr"
]
},
"z0brd"
]
},
{
"op": "*",
"args": [
"sncovr",
"z0eff"
]
}
]
}
},
{
"lhs": "snow_present",
"rhs": {
"op": "ifelse",
"args": [
{
"op": ">",
"args": [
"sncovr",
0.0
]
},
1.0,
0.0
]
}
}
],
"tests": [
{
"id": "cold_caseA_step1",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1 of case A, snow falling onto initially bare frozen ground: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step26",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 26 of case A, snow falling onto initially bare frozen ground: snow cover 0.0003, pack 0.0001 m, so 1.0499 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14999 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.00032981949957555656,
"z0brd": 0.15000000596046448,
"snowh": 6.265289281864245e-05
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000300844366,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step51",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 51 of case A, snow falling onto initially bare frozen ground: snow cover 0.0057, pack 0.0011 m, so 1.0489 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14985 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.005653097633327997,
"z0brd": 0.15000000596046448,
"snowh": 0.0010845807857592174
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1499991300688826,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step76",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 76 of case A, snow falling onto initially bare frozen ground: snow cover 0.0138, pack 0.0027 m, so 1.0473 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14962 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.01380810719384784,
"z0brd": 0.15000000596046448,
"snowh": 0.0026703651538401325
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14999473843356578,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step101",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 101 of case A, snow falling onto initially bare frozen ground: snow cover 0.0203, pack 0.0039 m, so 1.0461 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14944 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.020270196083057135,
"z0brd": 0.15000000596046448,
"snowh": 0.003943329211960439
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14998858709527213,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step328",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 328 of case A, snow falling onto initially bare frozen ground: snow cover 0.0392, pack 0.0074 m, so 1.0426 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14894 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.03923464557835188,
"z0brd": 0.15000000596046448,
"snowh": 0.0074008428492413885
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14995852461101147,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step364",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 364 of case A, snow falling onto initially bare frozen ground: snow cover 0.0440, pack 0.0082 m, so 1.0418 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14883 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.0440357188457946,
"z0brd": 0.15000000596046448,
"snowh": 0.00818199291833753
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14994853454050017,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step397",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 397 of case A, snow falling onto initially bare frozen ground: snow cover 0.0493, pack 0.0090 m, so 1.0410 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14871 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.049289188207118695,
"z0brd": 0.15000000596046448,
"snowh": 0.009015229530745133
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1499365269111686,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step519",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 519 of case A, snow falling onto initially bare frozen ground: snow cover 0.0688, pack 0.0121 m, so 1.0379 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14827 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.06881516109885122,
"z0brd": 0.15000000596046448,
"snowh": 0.012081330645061497
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14988123757266042,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step679",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 679 of case A, snow falling onto initially bare frozen ground: snow cover 0.0799, pack 0.0139 m, so 1.0361 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14802 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.07990083335811693,
"z0brd": 0.15000000596046448,
"snowh": 0.013881165534645721
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14984156071843588,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1761",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1761 of case A, snow falling onto initially bare frozen ground: snow cover 0.2053, pack 0.0380 m, so 1.0120 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14457 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2052709015400025,
"z0brd": 0.15000000596046448,
"snowh": 0.03803750872865951
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14888457828774054,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1824",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1824 of case A, snow falling onto initially bare frozen ground: snow cover 0.2065, pack 0.0361 m, so 1.0139 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14484 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.20645170152417336,
"z0brd": 0.15000000596046448,
"snowh": 0.036144647747286145
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489339882421189,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1849",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1849 of case A, snow falling onto initially bare frozen ground: snow cover 0.2053, pack 0.0352 m, so 1.0148 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14498 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.20534486366955518,
"z0brd": 0.15000000596046448,
"snowh": 0.03516868129373453
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489683333796502,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1874",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1874 of case A, snow falling onto initially bare frozen ground: snow cover 0.2041, pack 0.0342 m, so 1.0158 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14511 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.20409732784970258,
"z0brd": 0.15000000596046448,
"snowh": 0.03420854359865967
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14900259562644783,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1899",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1899 of case A, snow falling onto initially bare frozen ground: snow cover 0.2028, pack 0.0333 m, so 1.0167 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14525 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2027751380939995,
"z0brd": 0.15000000596046448,
"snowh": 0.03327560424805343
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.149036082353813,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step1924",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1924 of case A, snow falling onto initially bare frozen ground: snow cover 0.2015, pack 0.0324 m, so 1.0176 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14537 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2014609171200188,
"z0brd": 0.15000000596046448,
"snowh": 0.032383069396024984
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14906801698050956,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step2089",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2089 of case A, snow falling onto initially bare frozen ground: snow cover 0.2039, pack 0.0307 m, so 1.0193 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14562 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2038896504724078,
"z0brd": 0.15000000596046448,
"snowh": 0.030685460198750642
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14910622770982043,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step2114",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2114 of case A, snow falling onto initially bare frozen ground: snow cover 0.2149, pack 0.0325 m, so 1.0175 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14536 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.21490396307194037,
"z0brd": 0.15000000596046448,
"snowh": 0.032493770123206075
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14900242882123224,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step2847",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2847 of case A, snow falling onto initially bare frozen ground: snow cover 0.2188, pack 0.0332 m, so 1.0168 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14526 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.21882447332697563,
"z0brd": 0.15000000596046448,
"snowh": 0.03318041190505028
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489627650804795,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseA_step2880",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2880 of case A, snow falling onto initially bare frozen ground: snow cover 0.2188, pack 0.0332 m, so 1.0168 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14526 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.21882383072902312,
"z0brd": 0.15000000596046448,
"snowh": 0.03317866101861
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489628228600999,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3000 m, so 0.7500 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10714 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.29999998211860657
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10800000846385957,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step26",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 26 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3000 m, so 0.7500 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10714 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.300017416477351
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10799756765363534,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step51",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 51 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3010 m, so 0.7490 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10700 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.3009808361541236
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10786268889888719,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step100",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 100 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3038 m, so 0.7462 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10661 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.3037633597857571
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10747313559045849,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step435",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 435 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3098 m, so 0.7402 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10574 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.30981197953562284
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10662632882547728,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step463",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 463 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3104 m, so 0.7396 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10565 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.31043794751198717
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10653869330878628,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step492",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 492 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3108 m, so 0.7392 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10560 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.3108033537865341
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10648753643034971,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step517",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 517 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3109 m, so 0.7391 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10559 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.31090250611842846
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1064736551038845,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step561",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 561 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3117 m, so 0.7383 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10547 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.31172868609442167
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10635798990724545,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step658",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 658 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3112 m, so 0.7388 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10554 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.3112076222896576
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10643093883991242,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1612",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1612 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3085 m, so 0.7415 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10593 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.30848824977874756
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10681165099143983,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1637",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1637 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.3045 m, so 0.7455 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.10650 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.3044896721839905
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.10737145185470581,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1816",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1816 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.2567 m, so 0.7933 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.11332 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.25674816966056824
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.11405526220798493,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1841",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1841 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.2490 m, so 0.8010 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.11443 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.24898476898670197
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.11514213830232621,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step1866",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1866 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.2414 m, so 0.8086 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.11552 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.24135594069957733
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.11621017426252366,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step2122",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2122 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.1972 m, so 0.8528 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.12183 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.19721251726150513
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.12239025354385376,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseB_step2880",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2880 of case B, a 30 cm pack melting under warm advection: snow cover 0.9800, pack 0.1971 m, so 0.8529 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.12185 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.98,
"z0brd": 0.15000000596046448,
"snowh": 0.19706536829471588
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.12241085439920425,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2868, pack 0.0250 m, so 1.0250 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14643 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2867568586410364,
"z0brd": 0.15000000596046448,
"snowh": 0.02499999850988388
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489758743835038,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step26",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 26 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2869, pack 0.0250 m, so 1.0250 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14642 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2869335735641815,
"z0brd": 0.15000000596046448,
"snowh": 0.025049941614544026
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14897319606545945,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step56",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 56 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2917, pack 0.0263 m, so 1.0237 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14625 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.29172103106936875,
"z0brd": 0.15000000596046448,
"snowh": 0.026280164719684865
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14890479499636458,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step169",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 169 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.3062, pack 0.0300 m, so 1.0200 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14571 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.30620513880906053,
"z0brd": 0.15000000596046448,
"snowh": 0.03003288433059029
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1486862597439952,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step268",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 268 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.3090, pack 0.0308 m, so 1.0192 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14561 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.3090239097234353,
"z0brd": 0.15000000596046448,
"snowh": 0.030756682157600405
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1486422130789698,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step380",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 380 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.3015, pack 0.0287 m, so 1.0213 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14589 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.30149827075390057,
"z0brd": 0.15000000596046448,
"snowh": 0.02874927408994584
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1487617407571004,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step405",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 405 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2966, pack 0.0279 m, so 1.0221 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14601 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2965569687945533,
"z0brd": 0.15000000596046448,
"snowh": 0.027913276106119156
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1488174521674422,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step434",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 434 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2898, pack 0.0269 m, so 1.0231 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14616 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2898179234936723,
"z0brd": 0.15000000596046448,
"snowh": 0.026858793571591377
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14888798313468393,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step459",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 459 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2840, pack 0.0260 m, so 1.0240 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14629 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2839524246268551,
"z0brd": 0.15000000596046448,
"snowh": 0.02596842683851719
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1489466062798156,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step708",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 708 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2551, pack 0.0213 m, so 1.0287 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14696 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2551364065212315,
"z0brd": 0.15000000596046448,
"snowh": 0.02129247412085533
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14922393662715858,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step733",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 733 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2552, pack 0.0213 m, so 1.0287 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14696 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.25520360903512096,
"z0brd": 0.15000000596046448,
"snowh": 0.021298784762620926
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1492235021405383,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1564",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1564 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2572, pack 0.0215 m, so 1.0285 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14693 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.25718852393208325,
"z0brd": 0.15000000596046448,
"snowh": 0.02148446999490261
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14921064037111417,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1785",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1785 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2241, pack 0.0171 m, so 1.0329 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14755 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2241231849202019,
"z0brd": 0.15000000596046448,
"snowh": 0.01713281124830246
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1494514544999493,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1810",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1810 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2179, pack 0.0165 m, so 1.0335 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14765 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.21788963257664729,
"z0brd": 0.15000000596046448,
"snowh": 0.016465021297335625
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14948749775462974,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1838",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1838 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2110, pack 0.0157 m, so 1.0343 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14775 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.2110107330869384,
"z0brd": 0.15000000596046448,
"snowh": 0.015743093565106392
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14952544000128887,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1863",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1863 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.2051, pack 0.0151 m, so 1.0349 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14784 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.20508036098903404,
"z0brd": 0.15000000596046448,
"snowh": 0.015130738727748394
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1495567177661334,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1888",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1888 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1994, pack 0.0146 m, so 1.0354 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14792 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.19944155250189521,
"z0brd": 0.15000000596046448,
"snowh": 0.01455513946712017
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1495853060158639,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step1978",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1978 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1826, pack 0.0128 m, so 1.0372 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14816 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.1825810320054171,
"z0brd": 0.15000000596046448,
"snowh": 0.012845908291637897
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1496649460757596,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2003",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2003 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1791, pack 0.0125 m, so 1.0375 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14822 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.17905735152491842,
"z0brd": 0.15000000596046448,
"snowh": 0.012480990961194038
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1496807469339048,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2104",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2104 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1724, pack 0.0116 m, so 1.0384 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14834 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.17239880166574628,
"z0brd": 0.15000000596046448,
"snowh": 0.011629151180386543
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14971359857076613,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2119",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2119 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1724, pack 0.0116 m, so 1.0384 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14834 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.17239970117168413,
"z0brd": 0.15000000596046448,
"snowh": 0.011586623266339302
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14971464447636365,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2141",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2141 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1724, pack 0.0116 m, so 1.0384 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14834 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.1724340902973429,
"z0brd": 0.15000000596046448,
"snowh": 0.011589097790420055
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14971452659834192,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2166",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2166 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1725, pack 0.0116 m, so 1.0384 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14834 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.1724856975671265,
"z0brd": 0.15000000596046448,
"snowh": 0.01159284170717001
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14971434890494356,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseC_step2880",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2880 of case C, a thin pack over soil that thaws and refreezes: snow cover 0.1738, pack 0.0117 m, so 1.0383 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14833 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.17384175685001746,
"z0brd": 0.15000000596046448,
"snowh": 0.011691033840179443
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14970966455158308,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0033, pack 0.0003 m, so 1.0498 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14996 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.0033375665622663586,
"z0brd": 0.15000000596046448,
"snowh": 0.0002500000118743628
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14999988676165302,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step26",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 26 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0033, pack 0.0002 m, so 1.0498 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14996 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.0033351063534242664,
"z0brd": 0.15000000596046448,
"snowh": 0.0002498149697203189
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1499998869376798,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step51",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 51 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0033, pack 0.0002 m, so 1.0498 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14996 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.0033343338849722848,
"z0brd": 0.15000000596046448,
"snowh": 0.0002497566747479141
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1499998869930154,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step392",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 392 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0031, pack 0.0002 m, so 1.0498 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14997 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.003063456438819556,
"z0brd": 0.15000000596046448,
"snowh": 0.00021633169671986252
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14999991128578888,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step417",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 417 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0028, pack 0.0002 m, so 1.0498 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14997 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.002819363128271135,
"z0brd": 0.15000000596046448,
"snowh": 0.00019741823780350387
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.1499999264470787,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step521",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 521 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0008, pack 0.0001 m, so 1.0499 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.14999 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 0.0008068568553057931,
"z0brd": 0.15000000596046448,
"snowh": 5.456982398754917e-05
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.14999999967045924,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step553",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 553 of case D, a trace pack over frozen ground in a dry column: snow cover 0.0001, pack 0.0000 m, so 1.0500 m of the 1.05 m of vegetation is still standing proud and the snow-covered fraction's roughness is 0.15000 m against the background 0.15 m.",
"parameter_overrides": {
"sncovr": 8.368240136436e-05,
"z0brd": 0.15000000596046448,
"snowh": 5.6008470892265905e-06
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000589350843,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 1.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1000",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1000 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1025",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1025 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1501",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1501 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1526",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1526 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1564",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1564 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1787",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1787 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1813",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1813 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1838",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1838 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1928",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1928 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1934",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1934 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1935",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1935 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step1953",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 1953 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step2096",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2096 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step2144",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2144 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step2169",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2169 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
},
{
"id": "cold_caseD_step2880",
"description": "Reference: WRF 4.8 em_scm_xy COLD-SEASON single-column run, data/eqwefic/noahcold_scm, dumped by ctessum-claude/WRF branch earthsciml-instrumented-noahcold and replayed through the real64 (-fdefault-real-8) kernels/noah_driver at ESM_DT = 1e-6 s. `z0` is asserted against the Registry variable `z0_out`, which the driver already dumps -- SNOWZ0 needed no instrumentation, and the component reproduces it BITWISE at all 84 steps of the set, so `z0` is asserted at ZERO TOLERANCE rather than at the project's 1e-9 -- the same choice `frozen_soil.esm` made once its publisher removed the last cancelling difference. There is nothing here for a tolerance to absorb: the routine is four arithmetic operations on values the dump carries exactly. THE REPLAY PASS IS NOT CHOSEN FOR ACCURACY, because this routine has none of the step dependence that decided it for the two components next door: four lines of algebra on the current state, no dt in them and nothing differenced, so no pass is more precise than another (FORTRAN_BUGS N99's rule has nothing to bite on here, which is itself worth saying). It is chosen because it is the pass where the snow-cover input is unambiguous: at the 60 s pass, case D step 553's pack vanishes DURING the step and SNOPAC zeroes `sncovr` afterwards, so the dumped cover is no longer the one SNFRAC handed SNOWZ0 earlier in the same call. It is also the pass `snow_cover.esm` -- which supplies that input in an assembly -- is referenced against. TWO INPUTS ARE NOT THE OBVIOUS ONES. `z0brd` is REDPRM's greenness-selected value (`z0brd_out`), not the argument SFLX is passed: FORTRAN_BUGS N96, extended here to a fourth quantity, and live in this set -- the dumped argument takes 0.05 at some steps while the value the routine uses is 0.150000006 at every one. `snowh` is the CURRENT post-SNOW_NEW depth, not the previous step's that SFLX's comment above the call claims; the previous depth reproduces WRF to only 7.1e-12 relative against bitwise agreement with the current one. Step 2880 of case D, a trace pack over frozen ground in a dry column: NO SNOW COVER: the cover-weighted average degenerates to z0brd exactly, which is what SFLX's own `ELSE Z0 = Z0BRD` branch does, so this step tests that the guard is an optimisation and not a semantic branch on this path.",
"parameter_overrides": {
"sncovr": 0.0,
"z0brd": 0.15000000596046448,
"snowh": 0.0
},
"time_span": {
"start": 0.0,
"end": 0.0
},
"assertions": [
{
"variable": "z0",
"time": 0.0,
"expected": 0.15000000596046448,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "fully_buried",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
},
{
"variable": "snow_present",
"time": 0.0,
"expected": 0.0,
"tolerance": {
"abs": 0.0,
"rel": 0.0
}
}
]
}
]
}