From 823fde7912756dd78dad69cc41b7f3e5bf65839d Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 17:26:24 -0700 Subject: [PATCH 01/11] Initialize PWF baseline for #284 step 5 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- planning/active/findings.md | 67 +++++++++++++++++++ planning/active/progress.md | 8 +++ planning/active/task_plan.md | 125 +++++++++++++++++++++++++++++++++++ 3 files changed, 200 insertions(+) create mode 100644 planning/active/findings.md create mode 100644 planning/active/progress.md create mode 100644 planning/active/task_plan.md diff --git a/planning/active/findings.md b/planning/active/findings.md new file mode 100644 index 00000000..ef43c76c --- /dev/null +++ b/planning/active/findings.md @@ -0,0 +1,67 @@ +# Findings — #284 step 5 (scoring) + +## Issue context + +**If we do it:** CH and BT habitat in the `default_tuned` bundle rests on measured fish distributions and cited literature, with a recorded verdict per threshold. **If we never do:** both species keep inherited bcfishpass cutoffs, and the size difference that separates them (big-river CH spawning vs small-stream BT) is represented only by `spawn_channel_width_min` 4 vs 2. + +## Status (2026-09-26) + +Steps 1–4 and 6 are done; the verdicts are in [`research/habitat_thresholds.md`](https://github.com/NewGraphEnvironment/link/blob/main/research/habitat_thresholds.md). **Step 5 (scoring) is unblocked once #290 merges (PR #291).** DV→BT pooling now comes from `default`'s `species_pooling.csv`, by region. Step 1 was re-run under the regional rule, and no #284 number moved: all 55 WSGs are in pooled regions, so only the province-wide ledger step 3 changes (DV 8,888 → 6,138). The #283 baseline also re-runs byte-identical. The step 5 plan below stands. Its pilot WSGs are all pooled under the Hazelton split (BULK and MORR are above Hazelton). + +- **The Skeena is decided (2026-09-27): DV pools into BT only above Hazelton.** Skeena DV is a current name, not a legacy one. Under the split: + - pooled BT rearing gradient P95 is 0.1309, n 3,988 (was 0.1348, n 4,764); + - the rule still gives **0.1349**, but only 0.0009 above the line that would give 0.1249; + - no verdict moves. Details: [`research/species_pooling.md`](https://github.com/NewGraphEnvironment/link/blob/290-region-scoped-dv-bt-observation-pooling/research/species_pooling.md). + - **Step 5 must score both 0.1349 and 0.1249.** + - The tracker's new `obs_year_max` (pool only pre-1995 interior records, scenario S4) would keep 0.1349 by 0.0010. + +- **Step 5 plan (agreed 2026-09-26, run after #290):** + - Prepare each WSG once, then re-classify it per variant, so every variant shares its segmentation. `default` is re-run in the same harness: the existing `fresh_default` BULK is pre-#223, with 42,860 segments against 87,639. + - Seven variants: `default`, `default_tuned`, BT rear 0.1249 and 0.1449, CH spawn 0.0549 and 0.0299, and CH rear 0.0649. + - WSGs: BT is read on ELKR and BULL (held out), with PARS, KOTL, BULK and MORR in-sample. CH is read on UNTH and LNTH (held out), with BULK and MORR in-sample. + - Rule, fixed before the runs: the marginal band is habitat when its observation density per km is ≥ 0.5× the incumbent's. It is read on held-out WSGs and needs n ≥ 10, else keep. The literature veto stands. + - Everything is species-agnostic: variants, WSG roles and absence taxa are data. + +- **One value moves:** BT `rear_gradient_max` 0.1049 → 0.1349, in `default_tuned` (high confidence: BT and DV records pooled, n 4,764 accessible, P95 0.135; Isaak et al. 2015's 15 % natal envelope agrees). BT records alone give 0.1249, and both are recorded. Every other CH/BT gradient maximum and width minimum is kept, as are `spawn_gradient_min` (CH spawning selects the flattest bin, ratio 2.8) and the bridge (1.2 % of BT observations lost to clustering). So `default_tuned` still inherits `parameters_fresh.csv`. +- **Vetoed by the literature:** CH spawning width 6.6 m (Cooney & Holzer, Busch and Woll all put the minimum at 3.6–4 m). +- **Changed after the numbers were seen:** restricting use to accessible segments moved three verdicts (CH spawning 0.0549 → keep, CH rearing 0.0649 → keep, BT rearing 0.1349 → 0.1249, before pooling brought BT back to 0.1349). Scoring should test the retired CH values too. +- **Coverage is not interior-only:** about a third of the CH locations are in the lower Fraser and coastal Skeena, where ocean-type runs occur. The CH rearing verdict is sensitive to the gradient measure: the 100 m window gradient would give 0.0649 rather than keep. +- **BT and DV are pooled.** Inland, DV records are bull trout recorded under the other name; on the coast either occurs, and their habitat biology is treated as equivalent. BT has no life stage anywhere in bcfishobs, so the staged evidence is the DV records. With full confidence the rule would loosen BT spawning gradient (0.1949) and width (1.2 m); the literature vetoes both. +- **Step 2 route:** the FISS data-submission parse in `knowledge` (per-site width, gradient, effort, no-fish-captured) covers COTR, LNTH, PINE, UNTH and UPCE. Modelled width is good to about −30 % / +55 % of measured. + +## Problem + +Current values (fresh `parameters_habitat_thresholds.csv`; link `default/parameters_fresh.csv`): + +| | spawn gradient max | spawn cw min | rear gradient max | rear cw min | MAD | access gradient max | +|---|---|---|---|---|---|---| +| CH | 0.0449 | 4 | 0.0549 | 1.5 | spawn ≥ 0.46, rear 0.28–100 (**unused**: no WSG uses the `mad` method and streams carry no `mad_m3s` — fresh#114) | 0.15 | +| BT | 0.0549 | 2 | 0.1049 | 1.5 | — | 0.25 | + +Rearing-to-spawning connection is identical for both (`cluster_rearing = TRUE`, direction `both`, `cluster_bridge_gradient 0.05`, `cluster_bridge_distance 10000`). In fresh's `.frs_cluster_both()`, a rearing cluster is kept if spawning lies anywhere upstream of it, with no gradient test. Failing that, it is kept if a downstream trace reaches spawning within 10 km through reaches under the bridge gradient. So the 5 % bridge governs only rearing that sits above spawning. *(Corrected 2026-09-26: this previously said steep BT rearing "only survives with spawning upstream of it", which leaves out the downstream route.)* + +Channel width is mostly modelled: on the local `fresh.streams`, 1.38 M segments modelled, 98.5 k field-measured, 90 k river polygons and 2.19 M NULL. NULL fails every width test, and order-1 streams are NULL (fresh#28), which likely removes BT headwater rearing wholesale. *(Measured 2026-09-26: 49 % of accessible BT stream length in `fresh_default` has NULL width, while 4 % of BT observations on those streams sit there, a selection ratio of 0.08. That does not separate under-sampling of headwaters from absence.)* + +## Proposed Solution + +1. **Empirical distributions.** For CH and BT, join `bcfishobs.observations` (after `observation_exclusions`; release records removed) to segments. Plot gradient and channel width at observation points by life stage where known, by region, against the current cutoffs. Use measured channel width where it exists, and report modelled vs measured separately. +2. **Site-level evidence.** Add per-site measured width/gradient, effort, absences and fish size from FISS data submissions as an input table, to separate adult (spawning) from juvenile (rearing) evidence, especially for BT, where the provincial layer has no life stage. *(Fish size is not parsed yet: the `knowledge` parse covers site, collection and habitat sheets, not individual fish.)* +3. **Literature.** One cited value or range per threshold, including CH stream-type vs ocean-type and BT life-history forms. +4. **Candidates.** Set values in the `default_tuned` bundle (per-bundle thresholds, #282) for spawn/rear gradient max, channel width min, `spawn_gradient_min` (see the reverted 0.0025 floor in `research/default_vs_bcfishpass.md`), and BT `cluster_bridge_gradient`. +5. **Score.** Run `default` and `default_tuned` on pilot WSGs with both species present and good sampling, then compare with the observation validation (#283). +6. **Verdict** in `research/habitat_thresholds.md`, revised in place per species. + +Out of scope here: MAD (fresh#114), temperature/GSDD (#21), channel-class segmentation (#52). + +Relates to #20, #282, #283 + + + + + + + +## Errors Encountered + +| Error | Resolution | +|-------|------------| diff --git a/planning/active/progress.md b/planning/active/progress.md new file mode 100644 index 00000000..607999fd --- /dev/null +++ b/planning/active/progress.md @@ -0,0 +1,8 @@ +# Progress — #284 step 5 (scoring) + +## Session 2026-09-29 + +- Plan-mode exploration — phases approved by user; four gate decisions taken (adjacent-step bands, calibration-stage observations, exported `lnk_habitat_validate_band()`, full 20-WSG closure). +- Created branch `284-research-calibrate-ch-and-bt-gradient-an` off main (097419f). +- Scaffolded PWF baseline with approved phases. User: "go all phases" — run to PR. +- Next: Phase 1. diff --git a/planning/active/task_plan.md b/planning/active/task_plan.md new file mode 100644 index 00000000..7a2cf108 --- /dev/null +++ b/planning/active/task_plan.md @@ -0,0 +1,125 @@ +# Task: Research: calibrate CH and BT gradient and channel-width thresholds from observations (#284) — step 5 scoring + +**If we do it:** CH and BT habitat in the `default_tuned` bundle rests on measured fish distributions and cited literature, with a recorded verdict per threshold. Steps 1–4 and 6 shipped (PR #287); this PWF is step 5 — score the variants against the #283 validator. + +## Context + +#284 steps 1–4 and 6 shipped (PR #287): `default_tuned` differs from `default` in one cell, BT `rear_gradient_max` 0.1049 → 0.1349, and every verdict in `research/habitat_thresholds.md` is **unscored**. #283 built the validator (`lnk_habitat_validate()`, `data-raw/habitat_validate.R`) and #290 made DV→BT pooling data (Hazelton split). Under that split the 0.1349 value is only 0.0009 above the line that would give 0.1249, so step 5 must score both. + +The agreed step-5 design (issue body, 2026-09-26) is: +- Prepare each WSG once, then re-classify it once per variant, so all variants share segmentation. Full runs are not bit-reproducible: the PSCIS tie in `lnk_pipeline_pscis_build.R:264-279`. +- Seven variants and eight pilot WSGs. +- A decision rule fixed before any run. + +Decisions taken at this gate (2026-09-29): +- **Bands are adjacent steps.** Each variant is compared with its nearest tighter neighbour in its ladder. + - Band = segments that are habitat in the looser variant and not in the tighter one. + - Incumbent = `default`'s habitat of that flag, outside every band. + - Walk outward from `default` and stop at the first band that fails. +- **Observation stage = the stage each threshold was calibrated on:** BT rearing → any stage, CH spawning → spawn-staged, CH rearing → rear-staged. The other stages are reported beside it. +- **Export `lnk_habitat_validate_band()`** in the compare family. +- **Model the full 20-WSG drainage closure** into the base schema. + +**Rule (fixed now, written to the research doc before any run):** +- A band stays or becomes habitat when its observation density per km is ≥ 0.5× the incumbent's. +- It is read on the held-out WSGs for its species and needs n ≥ 10 observation locations in the band, else keep. +- The literature veto stands. +- In-sample WSGs are reported beside the verdict and never decide it. + +## Run decisions (stated here, restated above the launch command) + +- **config:** `default`, plus six thin variant bundles that `extends: default` and override only `parameters_habitat_thresholds.csv` and `pipeline.schema`. Not `bcfishpass`. +- **schemas:** `score284_`, 7 new schemas. `fresh_default` and `fresh` are untouched. +- **focal WSGs:** ELKR, BULL, PARS, KOTL, BULK, MORR, UNTH, LNTH. +- **closure:** `lnk_wsg_resolve(expand = TRUE)` gives 20 WSGs. It adds LARL, LFRA, LPCE, LSKE, HARR, KLUM, UPCE, FRCN, KISP, PCEA, PARA and THOM, 461k source segments. + - The closure is modelled downstream-first into `score284_default` only. + - Only the 8 focal WSGs are re-classified per variant. +- **species:** `cfg$species` × presence. The pilots carry BT everywhere and CH in BULK, MORR, UNTH and LNTH. +- **flags:** `dams = TRUE`, `mapping_code = FALSE`, `log = TRUE` on the base run. The post-model access recompute runs on the focal WSGs. No primitives refresh. +- **variants** (`data-raw/habitat_score/variants.csv`): `default`, `default_tuned` (BT rear 0.1349), BT rear 0.1249 and 0.1449, CH spawn 0.0549 and 0.0299, CH rear 0.0649. +- **roles** (`wsg_roles.csv`): + - BT: held out ELKR and BULL; in sample PARS, KOTL, BULK and MORR. + - CH: held out UNTH and LNTH; in sample BULK and MORR. +- **Measured cost basis:** m1 0.0391 min per 1000 persisted segments, with persisted ≈ 3.5× source. + - Base run ≈ 1 h. + - Six re-classify passes over 206k source segments ≈ 1–1.5 h. + - Disk: `fresh_default` is 7 GB for 55 WSGs; about 15 GB here, against 981 GB free. + +## Phase 1: Inputs as data +- [ ] `data-raw/habitat_score/variants.csv`: `variant, species_code, column, value, flag (spawning|rearing), obs_stage, tighter` (the ladder neighbour; `default` has none). Seven rows. No species is named in code. +- [ ] `data-raw/habitat_score/wsg_roles.csv`: `watershed_group_code, species_code, role (held_out|in_sample)`. +- [ ] `data-raw/fiss_absence_taxa.csv`: `species_code, role (caught|maybe), pattern`. It replaces the hard-coded `caught` / `maybe` regex lists in `data-raw/habitat_validate.R:170-177`. +- [ ] Extract the absence loader and the pooling resolution from `habitat_validate.R` into `data-raw/habitat_validate_inputs.R` (functions, sourced), so the scoring script uses the same code path rather than a copy. +- [ ] Verify with `LNK_KNOWLEDGE_DIR` set: re-run `habitat_validate.R --bundles=default:fresh_default,bcfishpass:fresh`. The CSVs in `data-raw/logs/habitat_validate_283/` must be byte-identical, `stamp.txt` aside. Also confirm that the absence counts would change with a taxa row removed (the guard fires). +- [ ] Write the rule, the band definition and the stage choice into `research/habitat_thresholds.md` §Step 5, **committed before any run**. + +## Phase 2: `lnk_habitat_validate_band()` (exported) +- [ ] `R/lnk_habitat_validate_band.R`. Arguments: `conn, aoi, species, flag, schema, schema_ref, observations` (a `lnk_habitat_validate()$observations` frame), `stage`. +- [ ] The function returns, per WSG × species, the band as `schema \ schema_ref` and `schema_ref \ schema`: + - `band_km` and `n_band` (stage-filtered observation locations on band segments); + - the incumbent's km and n (`schema_ref`'s flag outside the band); + - both densities and their ratio. +- [ ] Every join is on `(id_segment, watershed_group_code)`. Before counting, it fails loudly unless both schemas carry an identical segment set per WSG: an id_segment and length digest from `streams`. +- [ ] `tests/testthat/test-lnk_habitat_validate_band.R`, DB-gated like `test-lnk_habitat_validate.R`: + - band arithmetic on a small constructed pair of schemas; + - the guard erroring on mismatched segmentation, then restoring the defect and watching it go red; + - the empty-band case (ratio `NA`, not 0); + - the stage filter. +- [ ] A roxygen `@examples` block (`\dontrun`, DB), `@family compare`, `devtools::document()`, `pkgdown::check_pkgdown()`. + +## Phase 3: Variant build harness +- [ ] `data-raw/habitat_variants_build.R --variants= --roles= [--wsgs=] [--step=base|variants|all]`. It generates one thin bundle per variant into `data-raw/logs/habitat_score_284/bundles//` (`config.yaml` + thresholds CSV with checksum), loaded by path through `lnk_config()`. +- [ ] **Base run:** `lnk_pipeline_run()` for `default`, over the closure in `lnk_wsg_resolve()` order. + - `lnk_wsg_downstream_check()` runs before each WSG in error mode. + - The working schemas are `working_score_`, with `cleanup_working = FALSE` for focal WSGs only. + - The post-model access recompute (`lnk_access(merge = TRUE)`, as in `wsg_recompute_one.R`) runs on the focal WSGs. +- [ ] **Per variant × focal WSG:** + - `lnk_pipeline_classify()` and `lnk_pipeline_connect()` on the working schema, then `lnk_persist_init()` and `lnk_pipeline_persist()` into `score284_`; + - `streams_access` replaced with the rows from `score284_default`, since access does not depend on the habitat thresholds. +- [ ] **Invariants asserted after each variant:** + - the `streams` segment digest and the `streams_access` digest are identical to `score284_default` for every focal WSG; + - re-classifying `default` reproduces the base run's `streams_habitat` digest. +- [ ] Stamp: link and fresh SHAs, `run_uid`, variant bundle hashes, source counts and the bcfishobs row count. +- [ ] Pre-flight on BULL (smallest, 13k source segments) with `default` and `default_tuned`. The invariants must hold and the BT band must be non-empty, framed against `fresh_default` and `fresh` where they exist. + +## Phase 4: Full build +- [ ] Restate the run decisions and launch detached (`nohup … & disown`). The repo is not touched while it runs. +- [ ] Verify post-conditions against the DB, not the exit code: + - 20 WSGs in `score284_default`; + - the 8 focal WSGs in each variant schema; + - the invariants from Phase 3; + - `.log` rows present for the base run. +- [ ] Commit the run log and stamp to `data-raw/logs/habitat_score_284/` (redacted). + +## Phase 5: Score +- [ ] `data-raw/habitat_variants_score.R` sources `habitat_validate_inputs.R` for pooling (from `default`'s tracker) and absences, then runs `lnk_habitat_validate()` on every variant schema at buffers 0 and 100. Output: `summary.csv`, `totals.csv`. +- [ ] Bands per ladder step via `lnk_habitat_validate_band()` → `bands.csv`, which holds held-out and in-sample rows, the absence count in each band, and `n` and `density_ratio`. +- [ ] Apply the rule mechanically → `verdict.csv` (per ladder step: pass, fail or keep with n < 10, then the walked-out value). +- [ ] Question 2: the km of BT rearing newly admitted in each band that has spawning upstream (`fwa_upstream`) against bridge-only. Output: `bridge_band.csv`. +- [ ] Question 3: the CH spawn 0.0299 band (3–4.5 %) as its own row. + +## Phase 6: Verdict and landing +- [ ] Revise `research/habitat_thresholds.md` in place: + - the verdict table, now scored; + - the Step 5 results; + - the header status line. +- [ ] Update `habitat_validation.md`'s "Using it for #284 step 5" section. +- [ ] If the rule moves a value, edit `configs/default_tuned/parameters_habitat_thresholds.csv`, its `config.yaml` checksum and README, then check with `lnk_config_verify()` and `audit_configs.R`. If not, the README and config description lose "unscored". +- [ ] Update NEWS.md, the CLAUDE.md status and the #284 issue body (edited, not appended). + +## Validation + +- [ ] Tests pass (`devtools::test()`), `lintr::lint_package()` clean, and `devtools::check()`, since the new export needs a minor bump. +- [ ] `/code-check` clean on each commit. +- [ ] PWF checkboxes match landed work. +- [ ] `/planning-archive` on completion, then `/gh-pr-push`. + +## Verification (end to end) +- Phase 1: the #283 CSVs are byte-identical after the refactor. +- Phase 2: the tests, with the guard shown to fire. +- Phases 3–4: the DB invariants (identical segmentation and access across all 7 schemas, and the default re-classify digest equal to the base run) are the proof that each band difference is purely a threshold effect. +- Phase 5: `bands.csv` n and km reconcile with `summary.csv` totals: the `default_tuned` minus `default` rearing km equals the sum of the BT 0.1249 and 0.1349 band km. + +## Out of scope +- Dropping the `score284_*` schemas. They are kept until the verdict lands, and dropping them is a separate, asked step. +- MAD (fresh#114), GSDD (#21) and channel-class segmentation (#52). From 961c5f929c1df8af66bd6f459e165609df221083 Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 18:48:33 -0700 Subject: [PATCH 02/11] Absence taxa as data, shared validation inputs, and the #284 step 5 rule (#284) The FISS absence rules (which listed taxa mean caught / maybe) move from regexes in habitat_validate.R to data-raw/fiss_absence_taxa.csv, and the absence loader and pooling resolution move to habitat_validate_inputs.R so the step-5 scorer uses the same code path. With knowledge pinned at 508bf44 the six #283 CSVs are byte-identical. The scoring rule is fixed in research/habitat_thresholds.md before any run. A counts-only power check (data-raw/logs/habitat_score_284/ power_windows.*) showed the first held-out set could decide one step of six, so the design is BT only with a widened held-out set (operator's call); CH verdicts stay keep, unscored. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/fiss_absence_taxa.csv | 8 + data-raw/habitat_score/README.md | 31 ++++ data-raw/habitat_score/variants.csv | 5 + data-raw/habitat_score/wsg_roles.csv | 13 ++ data-raw/habitat_validate.R | 167 ++--------------- data-raw/habitat_validate_inputs.R | 170 ++++++++++++++++++ .../logs/habitat_score_284/power_windows.R | 54 ++++++ .../logs/habitat_score_284/power_windows.txt | 37 ++++ planning/active/findings.md | 35 ++++ planning/active/review-plan.md | 38 ++++ research/habitat_thresholds.md | 75 ++++++-- 11 files changed, 470 insertions(+), 163 deletions(-) create mode 100644 data-raw/fiss_absence_taxa.csv create mode 100644 data-raw/habitat_score/README.md create mode 100644 data-raw/habitat_score/variants.csv create mode 100644 data-raw/habitat_score/wsg_roles.csv create mode 100644 data-raw/habitat_validate_inputs.R create mode 100644 data-raw/logs/habitat_score_284/power_windows.R create mode 100644 data-raw/logs/habitat_score_284/power_windows.txt create mode 100644 planning/active/review-plan.md diff --git a/data-raw/fiss_absence_taxa.csv b/data-raw/fiss_absence_taxa.csv new file mode 100644 index 00000000..548940ff --- /dev/null +++ b/data-raw/fiss_absence_taxa.csv @@ -0,0 +1,8 @@ +species_code,role,pattern +CH,caught,Chinook +CH,maybe,Unidentified +CH,maybe,Salmon \(General\) +BT,caught,Bull Trout +BT,caught,Dolly Varden +BT,maybe,Unidentified +BT,maybe,Unidentifiable Trout diff --git a/data-raw/habitat_score/README.md b/data-raw/habitat_score/README.md new file mode 100644 index 00000000..b97f75cd --- /dev/null +++ b/data-raw/habitat_score/README.md @@ -0,0 +1,31 @@ +# habitat_score + +The inputs for scoring habitat-threshold variants against fish observations (#284 step 5). +The rule and the reasoning behind it are in `research/habitat_thresholds.md`, under +"Scoring design". Two scripts use these files: + +- `data-raw/habitat_variants_build.R` models every variant on one shared segmentation. +- `data-raw/habitat_variants_score.R` scores the variants and applies the rule. + +Everything species-specific is here, and neither script names a species. + +## `variants.csv` + +One row per variant. The row with an empty `column` is the base, `default`. Every other +row changes exactly one cell of `default`'s `parameters_habitat_thresholds.csv`. + +| column | meaning | +|---|---| +| `variant` | name, and the persist schema suffix (`score284_`) | +| `species_code` | the row of the thresholds table to change | +| `column` | the threshold column to change | +| `value` | the new value | +| `flag` | which `streams_habitat_` flag the step moves: `spawning` or `rearing` | +| `obs_stage` | which observations count in the band: `any`, `spawn` or `rear` (the stage the threshold was calibrated on) | +| `step_from` | the neighbour nearer `default` in the ladder; the band is the difference between the two | +| `equals_bundle` | a shipped bundle whose thresholds this variant must equal byte for byte (checked at build) | + +## `wsg_roles.csv` + +One row per WSG × species: `held_out` WSGs decide the rule; `in_sample` WSGs (among the +WSGs the step-1 percentiles came from) are reported beside it. diff --git a/data-raw/habitat_score/variants.csv b/data-raw/habitat_score/variants.csv new file mode 100644 index 00000000..0449a1a3 --- /dev/null +++ b/data-raw/habitat_score/variants.csv @@ -0,0 +1,5 @@ +variant,species_code,column,value,flag,obs_stage,step_from,equals_bundle +default,,,,,,,default +bt_rear_0p1249,BT,rear_gradient_max,0.1249,rearing,any,default, +bt_rear_0p1349,BT,rear_gradient_max,0.1349,rearing,any,bt_rear_0p1249,default_tuned +bt_rear_0p1449,BT,rear_gradient_max,0.1449,rearing,any,bt_rear_0p1349, diff --git a/data-raw/habitat_score/wsg_roles.csv b/data-raw/habitat_score/wsg_roles.csv new file mode 100644 index 00000000..049c1730 --- /dev/null +++ b/data-raw/habitat_score/wsg_roles.csv @@ -0,0 +1,13 @@ +watershed_group_code,species_code,role +ELKR,BT,held_out +BULL,BT,held_out +UARL,BT,held_out +REVL,BT,held_out +CLRH,BT,held_out +LILL,BT,held_out +BABL,BT,held_out +BABR,BT,held_out +PARS,BT,in_sample +KOTL,BT,in_sample +BULK,BT,in_sample +MORR,BT,in_sample diff --git a/data-raw/habitat_validate.R b/data-raw/habitat_validate.R index 88b90704..f5c9d108 100644 --- a/data-raw/habitat_validate.R +++ b/data-raw/habitat_validate.R @@ -24,10 +24,11 @@ # `knowledge` repo, FISS data-submission sites that were sampled (effort # recorded or no-fish-captured) become absences of a species when either # - no fish were caught (`nfc`) and no species is listed, or -# - species are listed, none is the species (BT: Bull Trout or Dolly -# Varden, pooled as the observations are), and none is a taxon that could -# be it (`Unidentified Species`; `Salmon (General)` for CH; -# `Unidentifiable Trout` for BT). +# - species are listed, none is the species, and none is a taxon that +# could be it. Both lists are data, in data-raw/fiss_absence_taxa.csv +# (for BT, Bull Trout or Dolly Varden is caught, pooled as the +# observations are; `Unidentified Species` and `Unidentifiable Trout` may +# be it). # A site that caught fish but listed no species (most sites with an empty # list) says nothing about which species were absent, and is left out. # Sites snap to the nearest FWA stream within 100 m, the distance bcfishobs @@ -94,6 +95,12 @@ outputs <- c("summary.csv", "totals.csv", "totals_shared.csv", "misses.csv", "misses_binned.csv", "diff.csv", "stamp.txt") unlink(file.path(dir_out, outputs)) +# Taken at launch: the stamp names the code that ran, not the code at the end. +head_sha <- system("git rev-parse --short HEAD", intern = TRUE) +link_dirty <- length(system(paste( + "git status --porcelain -- R inst/extdata", + "data-raw/habitat_validate.R data-raw/habitat_validate_inputs.R", + "data-raw/fiss_absence_taxa.csv"), intern = TRUE)) > 0L conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, user = "postgres", password = "postgres") @@ -118,150 +125,15 @@ if (nrow(bundles) == 2L && stop("the two bundles share no WSGs", call. = FALSE) } -# -- absences from FISS sites (optional) -------------------------------------- -fiss_absences <- function() { - dir_k <- Sys.getenv("LNK_KNOWLEDGE_DIR", "") - if (!nzchar(dir_k)) return(NULL) - files <- Sys.glob(file.path(dir_k, "data", "*", "fiss_sites_*_all.csv")) - if (length(files) == 0L) { - stop("LNK_KNOWLEDGE_DIR set but no fiss_sites_*_all.csv under ", dir_k, - call. = FALSE) - } - num <- function(x) suppressWarnings(as.numeric(x)) - sites <- do.call(rbind, lapply(files, function(f) { - d <- utils::read.csv(f, colClasses = "character", na.strings = c("", "NA")) - data.frame(site_key = d$site_key, - utm_zone = num(d$utm_zone), utm_easting = num(d$utm_easting), - utm_northing = num(d$utm_northing), - sampled = d$effort_recorded %in% "TRUE" | d$nfc %in% "TRUE", - nfc = d$nfc %in% "TRUE", - species_list = ifelse(is.na(d$species_list), "", - d$species_list), - stringsAsFactors = FALSE) - })) - sites <- sites[sites$sampled & !is.na(sites$utm_zone) & - !is.na(sites$utm_easting) & !is.na(sites$utm_northing), ] - # A report spanning two groups appears in both snapshots under one key. - sites <- sites[!duplicated(sites$site_key), ] - dbWriteTable(conn, "hv_fiss", sites[, c("site_key", "utm_zone", - "utm_easting", "utm_northing")], - temporary = TRUE, overwrite = TRUE) - snap <- dbGetQuery(conn, " - WITH p AS ( - SELECT site_key, - st_transform(st_setsrid(st_makepoint(utm_easting, utm_northing), - 26900 + utm_zone::int), 3005) AS geom - FROM pg_temp.hv_fiss) - SELECT p.site_key, f.watershed_group_code, f.blue_line_key, - f.downstream_route_measure - + st_linelocatepoint(st_force2d(f.geom), p.geom) * f.length_metre - AS downstream_route_measure - FROM p - JOIN LATERAL ( - SELECT f.watershed_group_code, f.blue_line_key, - f.downstream_route_measure, f.length_metre, f.geom - FROM whse_basemapping.fwa_stream_networks_sp f - WHERE st_dwithin(f.geom, p.geom, 100) - AND f.edge_type <> 1425 - ORDER BY f.geom <-> p.geom - LIMIT 1) f ON true") - sites <- merge(sites, snap, by = "site_key") - # Only the snapshot WSGs were surveyed; a site snapping across a boundary - # would give its neighbour a partial count that reads as coverage. - covered <- toupper(basename(dirname(files))) - sites <- sites[sites$watershed_group_code %in% covered, ] - listed <- nzchar(trimws(sites$species_list)) - no_fish <- sites$nfc & !listed - caught <- list( - CH = grepl("Chinook", sites$species_list, ignore.case = TRUE), - BT = grepl("Bull Trout|Dolly Varden", sites$species_list, - ignore.case = TRUE)) - maybe <- list( - CH = grepl("Unidentified|Salmon \\(General\\)", sites$species_list, - ignore.case = TRUE), - BT = grepl("Unidentified|Unidentifiable Trout", sites$species_list, - ignore.case = TRUE)) - sp_abs <- intersect(species, names(caught)) - if (length(setdiff(species, sp_abs)) > 0L) { - message("no FISS absence rule for: ", - paste(setdiff(species, sp_abs), collapse = ", "), - "; not assessed") - } - if (length(sp_abs) == 0L) { - return(structure(list(), reason = "no FISS absence rule for the species")) - } - is_abs_of <- function(sp) no_fish | (listed & !caught[[sp]] & !maybe[[sp]]) - n_abs <- vapply(sp_abs, function(sp) sum(is_abs_of(sp)), integer(1)) - out <- do.call(rbind, lapply(sp_abs, function(sp) { - s <- sites[is_abs_of(sp), ] - data.frame(watershed_group_code = s$watershed_group_code, - blue_line_key = s$blue_line_key, - downstream_route_measure = s$downstream_route_measure, - species_code = rep(sp, nrow(s)), stringsAsFactors = FALSE) - })) - attr(out, "n_sites_sampled") <- nrow(sites) - attr(out, "n_absence_sites") <- n_abs - attr(out, "covered") <- sort(unique(covered)) - sha <- suppressWarnings(tryCatch( - system2("git", c("-C", shQuote(dir_k), "rev-parse", "--short", "HEAD"), - stdout = TRUE, stderr = FALSE), - error = function(e) character(0))) - attr(out, "knowledge_sha") <- if (length(sha) == 1L) sha else "not a git repo" - out -} -absences <- fiss_absences() +# -- absences (optional) and pooling: data-raw/habitat_validate_inputs.R ------- +source(file.path("data-raw", "habitat_validate_inputs.R")) +absences <- hv_fiss_absences(conn, species) abs_note <- attr(absences, "reason") if (!is.null(abs_note)) absences <- NULL -# -- pooling: resolved once, from one bundle ----------------------------------- -if (is.null(pooling_cfg)) { - declares <- vapply(bundles$config, function(b) { - !is.null(lnk_config(b)$files$species_pooling) - }, logical(1)) - pooling_cfg <- if (any(declares)) bundles$config[which(declares)[1]] else NULL -} -loaded_pool <- if (is.null(pooling_cfg)) list() else - suppressWarnings(lnk_load_overrides(lnk_config(pooling_cfg))) -args_pool <- list() -pooling_note <- "no bundle declares a species_pooling tracker: lnk_habitat_validate() default" -if (!is.null(pooling_cfg) && is.null(loaded_pool$species_pooling)) { - stop("--pooling=", pooling_cfg, " declares no species_pooling tracker", - call. = FALSE) -} -if (!is.null(loaded_pool$species_pooling)) { - # The pooling table is resolved against the pooling bundle's presence, and - # each bundle is then scored against its own. If they disagree on a species - # in play, pooled records drop silently in the WSGs where they differ. - presence_flags <- function(p, w) { - p <- as.data.frame(p) - names(p) <- tolower(names(p)) - p <- p[match(w, toupper(p$watershed_group_code)), tolower(species), drop = FALSE] - vapply(p, function(x) as.character(x) %in% "t", logical(length(w))) - } - for (i in seq_len(nrow(bundles))) { - lp <- suppressWarnings(lnk_load_overrides(lnk_config(bundles$config[i]))) - w <- bundle_wsgs[[i]] - if (!identical(presence_flags(lp$wsg_species_presence, w), - presence_flags(loaded_pool$wsg_species_presence, w))) { - stop("bundle ", bundles$config[i], "'s wsg_species_presence differs ", - "from --pooling=", pooling_cfg, "'s for ", - paste(species, collapse = ", "), " in its WSGs", call. = FALSE) - } - } - args_pool$species_obs <- lnk_species_pooling( - loaded_pool, aoi = sort(unique(unlist(bundle_wsgs))), species = species) - pooled <- args_pool$species_obs[args_pool$species_obs$scope_level != "self", ] - pooling_note <- sprintf("%s species_pooling.csv (sha256 %s): %d WSG x species pairs pooled (%s)", - pooling_cfg, - substr(digest::digest( - file = lnk_config(pooling_cfg)$files$species_pooling$path, - algo = "sha256"), 1, 12), nrow(unique(pooled[c("watershed_group_code", - "species_code")])), - if (nrow(pooled) == 0L) "none" else - paste(unique(paste0(pooled$species_code, "<-", - pooled$obs_species)), - collapse = ", ")) -} +pool <- hv_pooling(bundles, bundle_wsgs, species, pooling_cfg) +args_pool <- pool$args +pooling_note <- pool$note # -- validate ------------------------------------------------------------------ runs <- list() @@ -415,9 +287,6 @@ if (nrow(bundles) == 2L) { # -- stamp --------------------------------------------------------------------------- fresh_sha <- .lnk_pkg_git_sha("fresh") -link_dirty <- length(system(paste( - "git status --porcelain -- R inst/extdata/configs", - "data-raw/habitat_validate.R"), intern = TRUE)) > 0L log_lines <- vapply(seq_len(nrow(bundles)), function(i) { s <- bundles$schema[i] w <- bundle_wsgs[[i]] @@ -439,7 +308,7 @@ log_lines <- vapply(seq_len(nrow(bundles)), function(i) { stamp <- c( sprintf("date: %s", format(Sys.time(), "%Y-%m-%d %H:%M %Z")), sprintf("link: %s @ %s%s", utils::packageVersion("link"), - system("git rev-parse --short HEAD", intern = TRUE), + head_sha, if (link_dirty) " (dirty)" else ""), sprintf("fresh installed (builds the miss-reason predicates): %s @ %s", utils::packageVersion("fresh"), diff --git a/data-raw/habitat_validate_inputs.R b/data-raw/habitat_validate_inputs.R new file mode 100644 index 00000000..26a82504 --- /dev/null +++ b/data-raw/habitat_validate_inputs.R @@ -0,0 +1,170 @@ +# habitat_validate_inputs.R — inputs shared by the observation-validation +# drivers (data-raw/habitat_validate.R, link#283; data-raw/habitat_variants_score.R, +# link#284 step 5). Sourced, not run: each function takes what it needs, so both +# drivers resolve absences and pooling through one code path. +# +# hv_fiss_absences() FISS data-submission sites (private `knowledge` repo, +# LNK_KNOWLEDGE_DIR) as absences of each species, by the +# taxa rules in data-raw/fiss_absence_taxa.csv +# hv_pooling() which observation species count as each model species, +# resolved once from one bundle's species_pooling.csv + +# -- absences from FISS sites (optional) -------------------------------------- +# Returns NULL when LNK_KNOWLEDGE_DIR is unset, or an empty list carrying a +# `reason` attribute when no species in `species` has an absence rule. +hv_fiss_absences <- function(conn, species, + taxa_csv = file.path("data-raw", "fiss_absence_taxa.csv")) { + dir_k <- Sys.getenv("LNK_KNOWLEDGE_DIR", "") + if (!nzchar(dir_k)) return(NULL) + files <- Sys.glob(file.path(dir_k, "data", "*", "fiss_sites_*_all.csv")) + if (length(files) == 0L) { + stop("LNK_KNOWLEDGE_DIR set but no fiss_sites_*_all.csv under ", dir_k, + call. = FALSE) + } + num <- function(x) suppressWarnings(as.numeric(x)) + sites <- do.call(rbind, lapply(files, function(f) { + d <- utils::read.csv(f, colClasses = "character", na.strings = c("", "NA")) + data.frame(site_key = d$site_key, + utm_zone = num(d$utm_zone), utm_easting = num(d$utm_easting), + utm_northing = num(d$utm_northing), + sampled = d$effort_recorded %in% "TRUE" | d$nfc %in% "TRUE", + nfc = d$nfc %in% "TRUE", + species_list = ifelse(is.na(d$species_list), "", + d$species_list), + stringsAsFactors = FALSE) + })) + sites <- sites[sites$sampled & !is.na(sites$utm_zone) & + !is.na(sites$utm_easting) & !is.na(sites$utm_northing), ] + # A report spanning two groups appears in both snapshots under one key. + sites <- sites[!duplicated(sites$site_key), ] + dbWriteTable(conn, "hv_fiss", sites[, c("site_key", "utm_zone", + "utm_easting", "utm_northing")], + temporary = TRUE, overwrite = TRUE) + snap <- dbGetQuery(conn, " + WITH p AS ( + SELECT site_key, + st_transform(st_setsrid(st_makepoint(utm_easting, utm_northing), + 26900 + utm_zone::int), 3005) AS geom + FROM pg_temp.hv_fiss) + SELECT p.site_key, f.watershed_group_code, f.blue_line_key, + f.downstream_route_measure + + st_linelocatepoint(st_force2d(f.geom), p.geom) * f.length_metre + AS downstream_route_measure + FROM p + JOIN LATERAL ( + SELECT f.watershed_group_code, f.blue_line_key, + f.downstream_route_measure, f.length_metre, f.geom + FROM whse_basemapping.fwa_stream_networks_sp f + WHERE st_dwithin(f.geom, p.geom, 100) + AND f.edge_type <> 1425 + ORDER BY f.geom <-> p.geom + LIMIT 1) f ON true") + sites <- merge(sites, snap, by = "site_key") + # Only the snapshot WSGs were surveyed; a site snapping across a boundary + # would give its neighbour a partial count that reads as coverage. + covered <- toupper(basename(dirname(files))) + sites <- sites[sites$watershed_group_code %in% covered, ] + listed <- nzchar(trimws(sites$species_list)) + no_fish <- sites$nfc & !listed + # Which listed taxa mean the species was caught, or might have been, is + # data (fiss_absence_taxa.csv): one regex per row, OR-ed per species x + # role and matched case-insensitively. A species with no `caught` row has + # no absence rule. + taxa <- utils::read.csv(taxa_csv, stringsAsFactors = FALSE, + colClasses = "character") + stopifnot(identical(names(taxa), c("species_code", "role", "pattern")), + all(taxa$role %in% c("caught", "maybe")), + all(nzchar(taxa$pattern))) + rule <- function(sp, role) { + p <- taxa$pattern[taxa$species_code == sp & taxa$role == role] + if (length(p) == 0L) return(rep(FALSE, nrow(sites))) + grepl(paste(p, collapse = "|"), sites$species_list, ignore.case = TRUE) + } + sp_rule <- unique(taxa$species_code[taxa$role == "caught"]) + caught <- stats::setNames(lapply(sp_rule, rule, role = "caught"), sp_rule) + maybe <- stats::setNames(lapply(sp_rule, rule, role = "maybe"), sp_rule) + sp_abs <- intersect(species, names(caught)) + if (length(setdiff(species, sp_abs)) > 0L) { + message("no FISS absence rule for: ", + paste(setdiff(species, sp_abs), collapse = ", "), + "; not assessed") + } + if (length(sp_abs) == 0L) { + return(structure(list(), reason = "no FISS absence rule for the species")) + } + is_abs_of <- function(sp) no_fish | (listed & !caught[[sp]] & !maybe[[sp]]) + n_abs <- vapply(sp_abs, function(sp) sum(is_abs_of(sp)), integer(1)) + out <- do.call(rbind, lapply(sp_abs, function(sp) { + s <- sites[is_abs_of(sp), ] + data.frame(watershed_group_code = s$watershed_group_code, + blue_line_key = s$blue_line_key, + downstream_route_measure = s$downstream_route_measure, + species_code = rep(sp, nrow(s)), stringsAsFactors = FALSE) + })) + attr(out, "n_sites_sampled") <- nrow(sites) + attr(out, "n_absence_sites") <- n_abs + attr(out, "covered") <- sort(unique(covered)) + sha <- suppressWarnings(tryCatch( + system2("git", c("-C", shQuote(dir_k), "rev-parse", "--short", "HEAD"), + stdout = TRUE, stderr = FALSE), + error = function(e) character(0))) + attr(out, "knowledge_sha") <- if (length(sha) == 1L) sha else "not a git repo" + out +} + +# -- pooling: resolved once, from one bundle ----------------------------------- +# `bundles` is a data frame with a `config` column; `bundle_wsgs` the list of +# each bundle's WSGs. Returns list(args = , +# note = ). +hv_pooling <- function(bundles, bundle_wsgs, species, pooling_cfg = NULL) { + if (is.null(pooling_cfg)) { + declares <- vapply(bundles$config, function(b) { + !is.null(lnk_config(b)$files$species_pooling) + }, logical(1)) + pooling_cfg <- if (any(declares)) bundles$config[which(declares)[1]] else NULL + } + loaded_pool <- if (is.null(pooling_cfg)) list() else + suppressWarnings(lnk_load_overrides(lnk_config(pooling_cfg))) + args_pool <- list() + pooling_note <- "no bundle declares a species_pooling tracker: lnk_habitat_validate() default" + if (!is.null(pooling_cfg) && is.null(loaded_pool$species_pooling)) { + stop("--pooling=", pooling_cfg, " declares no species_pooling tracker", + call. = FALSE) + } + if (!is.null(loaded_pool$species_pooling)) { + # The pooling table is resolved against the pooling bundle's presence, and + # each bundle is then scored against its own. If they disagree on a species + # in play, pooled records drop silently in the WSGs where they differ. + presence_flags <- function(p, w) { + p <- as.data.frame(p) + names(p) <- tolower(names(p)) + p <- p[match(w, toupper(p$watershed_group_code)), tolower(species), drop = FALSE] + vapply(p, function(x) as.character(x) %in% "t", logical(length(w))) + } + for (i in seq_len(nrow(bundles))) { + lp <- suppressWarnings(lnk_load_overrides(lnk_config(bundles$config[i]))) + w <- bundle_wsgs[[i]] + if (!identical(presence_flags(lp$wsg_species_presence, w), + presence_flags(loaded_pool$wsg_species_presence, w))) { + stop("bundle ", bundles$config[i], "'s wsg_species_presence differs ", + "from --pooling=", pooling_cfg, "'s for ", + paste(species, collapse = ", "), " in its WSGs", call. = FALSE) + } + } + args_pool$species_obs <- lnk_species_pooling( + loaded_pool, aoi = sort(unique(unlist(bundle_wsgs))), species = species) + pooled <- args_pool$species_obs[args_pool$species_obs$scope_level != "self", ] + pooling_note <- sprintf("%s species_pooling.csv (sha256 %s): %d WSG x species pairs pooled (%s)", + pooling_cfg, + substr(digest::digest( + file = lnk_config(pooling_cfg)$files$species_pooling$path, + algo = "sha256"), 1, 12), nrow(unique(pooled[c("watershed_group_code", + "species_code")])), + if (nrow(pooled) == 0L) "none" else + paste(unique(paste0(pooled$species_code, "<-", + pooled$obs_species)), + collapse = ", ")) + } + + list(args = args_pool, note = pooling_note) +} diff --git a/data-raw/logs/habitat_score_284/power_windows.R b/data-raw/logs/habitat_score_284/power_windows.R new file mode 100644 index 00000000..b7272be9 --- /dev/null +++ b/data-raw/logs/habitat_score_284/power_windows.R @@ -0,0 +1,54 @@ +# power_windows.R — observation locations per band window, counts only (link#284 step 5). +# Run 2026-09-29 against docker fwapg before any variant was built; output in power_windows.txt. +# FWA segment gradient of the containing segment, A/B matches, Releases dropped, #290 pooling; +# no access, width or cluster filter, so every count is an upper bound. +suppressMessages(pkgload::load_all(quiet = TRUE)) +library(DBI) +conn <- lnk_db_conn(dbname="fwapg", host="localhost", port=5432L, user="postgres", password="postgres") +cfg <- lnk_config("default"); loaded <- suppressWarnings(lnk_load_overrides(cfg)) +calib <- dbGetQuery(conn, "SELECT DISTINCT watershed_group_code FROM fresh_default.streams_access")[[1]] +p <- as.data.frame(loaded$wsg_species_presence); names(p) <- tolower(names(p)) +bt_w <- toupper(p$watershed_group_code[p$bt %in% "t"]); ch_w <- toupper(p$watershed_group_code[p$ch %in% "t"]) +pool <- lnk_species_pooling(loaded, aoi = sort(unique(c(bt_w, ch_w))), species = c("BT","CH")) +spec <- unique(rbind(pool[, c("watershed_group_code","species_code","obs_species")], + data.frame(watershed_group_code = bt_w, species_code = "BT", obs_species = "BT"), + data.frame(watershed_group_code = ch_w, species_code = "CH", obs_species = "CH"))) +spec <- spec[(spec$species_code == "BT" & spec$watershed_group_code %in% bt_w) | (spec$species_code == "CH" & spec$watershed_group_code %in% ch_w), ] +dbWriteTable(conn, "pw_spec", spec, temporary = TRUE, overwrite = TRUE) +# One row per species x blue_line_key x metre; staged if any record there is, +# as lnk_habitat_validate() dedups. +o <- dbGetQuery(conn, " + SELECT sp.species_code, min(o.watershed_group_code) AS watershed_group_code, + min(s.gradient) AS gradient, + coalesce(bool_or(o.activity_code ~ '\\m(SPL|SPM|S)\\M' OR o.activity ~ 'Spawning'), false) AS is_spawn, + coalesce(bool_or(o.activity_code ~ '\\m(R|REA)\\M' OR o.activity ~ 'Rearing' OR o.life_stage ~ 'Fry|Parr|Juvenile'), false) AS is_rear + FROM bcfishobs.observations o + JOIN pg_temp.pw_spec sp ON sp.watershed_group_code = o.watershed_group_code AND sp.obs_species = o.species_code + JOIN whse_basemapping.fwa_stream_networks_sp s ON s.blue_line_key = o.blue_line_key + AND o.downstream_route_measure >= s.downstream_route_measure AND o.downstream_route_measure < s.upstream_route_measure + WHERE left(o.match_type,1) IN ('A','B') AND coalesce(o.source,'') NOT LIKE 'Releases Database%' + GROUP BY sp.species_code, o.blue_line_key, round(o.downstream_route_measure)") +o$is_spawn[is.na(o$is_spawn)] <- FALSE; o$is_rear[is.na(o$is_rear)] <- FALSE +win <- list(bt_1049_1249 = c("BT","any",0.1049,0.1249), bt_1249_1349 = c("BT","any",0.1249,0.1349), + bt_1349_1449 = c("BT","any",0.1349,0.1449), ch_sp_0299_0449 = c("CH","spawn",0.0299,0.0449), + ch_sp_0449_0549 = c("CH","spawn",0.0449,0.0549), ch_re_0549_0649 = c("CH","rear",0.0549,0.0649)) +cnt <- function(sel) sapply(win, function(w) { d <- o[sel & o$species_code == w[1] & o$gradient > as.numeric(w[3]) & o$gradient <= as.numeric(w[4]), ] + if (w[2] == "spawn") d <- d[d$is_spawn, ]; if (w[2] == "rear") d <- d[d$is_rear, ]; nrow(d) }) +cat("held-out BT ELKR+BULL / CH UNTH+LNTH:\n"); print(cnt(o$watershed_group_code %in% c("ELKR","BULL","UNTH","LNTH"))) +cat("widened held-out BT (ELKR BULL UARL REVL CLRH LILL BABL BABR):\n"); print(cnt(o$watershed_group_code %in% c("ELKR","BULL","UARL","REVL","CLRH","LILL","BABL","BABR"))) +cat("all 8 pilots:\n"); print(cnt(o$watershed_group_code %in% c("ELKR","BULL","UNTH","LNTH","PARS","KOTL","BULK","MORR"))) +cat("all non-calibration WSGs:\n"); print(cnt(!o$watershed_group_code %in% calib)) +cat("calibration 55:\n"); print(cnt(o$watershed_group_code %in% calib)) +nc <- o[!o$watershed_group_code %in% calib & o$species_code == "BT" & o$gradient > 0.1049 & o$gradient <= 0.1449, ] +cat("top non-calibration BT WSGs, 0.1049-0.1449 window:\n"); print(head(sort(table(nc$watershed_group_code), decreasing = TRUE), 15)) +nc2 <- o[!o$watershed_group_code %in% calib & o$species_code == "BT" & o$gradient > 0.1249 & o$gradient <= 0.1349, ] +print(head(sort(table(nc2$watershed_group_code), decreasing = TRUE), 15)) +cat("n non-calib BT WSGs:", length(setdiff(bt_w, calib)), "; n non-calib CH WSGs:", length(setdiff(ch_w, calib)), "\n") +cat("densest non-calibration CH WSGs per CH window:\n") +ch <- o[o$species_code == "CH" & !o$watershed_group_code %in% calib, ] +for (w in list(c("spawn", 0.0299, 0.0449), c("spawn", 0.0449, 0.0549), c("rear", 0.0549, 0.0649))) { + d <- ch[ch$gradient > as.numeric(w[2]) & ch$gradient <= as.numeric(w[3]) & + (if (w[1] == "spawn") ch$is_spawn else ch$is_rear), ] + t <- sort(table(d$watershed_group_code), decreasing = TRUE)[1:6] + cat(" ", w, ":", paste(names(t), t), "\n") +} diff --git a/data-raw/logs/habitat_score_284/power_windows.txt b/data-raw/logs/habitat_score_284/power_windows.txt new file mode 100644 index 00000000..384c1576 --- /dev/null +++ b/data-raw/logs/habitat_score_284/power_windows.txt @@ -0,0 +1,37 @@ +held-out BT ELKR+BULL / CH UNTH+LNTH: + bt_1049_1249 bt_1249_1349 bt_1349_1449 ch_sp_0299_0449 ch_sp_0449_0549 + 10 1 0 0 1 +ch_re_0549_0649 + 2 +widened held-out BT (ELKR BULL UARL REVL CLRH LILL BABL BABR): + bt_1049_1249 bt_1249_1349 bt_1349_1449 ch_sp_0299_0449 ch_sp_0449_0549 + 43 33 22 0 0 +ch_re_0549_0649 + 2 +all 8 pilots: + bt_1049_1249 bt_1249_1349 bt_1349_1449 ch_sp_0299_0449 ch_sp_0449_0549 + 66 15 17 2 1 +ch_re_0549_0649 + 2 +all non-calibration WSGs: + bt_1049_1249 bt_1249_1349 bt_1349_1449 ch_sp_0299_0449 ch_sp_0449_0549 + 95 45 35 35 19 +ch_re_0549_0649 + 17 +calibration 55: + bt_1049_1249 bt_1249_1349 bt_1349_1449 ch_sp_0299_0449 ch_sp_0449_0549 + 160 37 35 10 2 +ch_re_0549_0649 + 12 +top non-calibration BT WSGs, 0.1049-0.1449 window: + +BABR UARL DUNC REVL BABL LILL CARR KHOR KOTR SMAR CLRH ELKR HERR LNIC UNTH + 23 21 18 14 13 13 9 8 8 7 6 6 3 3 3 + +UARL REVL CLRH LILL BABL BABR HERR KOTR SMAR COLR ELKR GATA LNAR MURR TASR + 9 7 6 5 3 2 2 2 2 1 1 1 1 1 1 +n non-calib BT WSGs: 106 ; n non-calib CH WSGs: 94 +densest non-calibration CH WSGs per CH window: + spawn 0.0299 0.0449 : OWIK 5 BELA 4 KITR 2 LNAR 2 LNIC 2 STIR 2 + spawn 0.0449 0.0549 : LISR 2 SEYM 2 TSAY 2 KSHR 1 LNAR 1 LNIC 1 + rear 0.0549 0.0649 : CARR 5 LILL 2 UNTH 2 CLAY 1 HERR 1 KITR 1 diff --git a/planning/active/findings.md b/planning/active/findings.md index ef43c76c..4bd0fab7 100644 --- a/planning/active/findings.md +++ b/planning/active/findings.md @@ -61,7 +61,42 @@ Relates to #20, #282, #283 +## Plan review and power check (2026-09-29) + +`review-plan.md` holds every finding and what was done with it. The one that changed the +design: held-out observation locations per band window (FWA gradient, upper bounds, +`data-raw/logs/habitat_score_284/power_windows.txt`, now deterministic through +`bool_or` per location — the first `DISTINCT ON` draft moved staged CH counts by one +between runs): + +| window | ELKR+BULL / UNTH+LNTH | widened BT set | 8 pilots | non-calibration | +|---|---|---|---|---| +| BT 0.1049–0.1249 | 10 | 43 | 66 | 95 | +| BT 0.1249–0.1349 | 1 | 33 | 15 | 45 | +| BT 0.1349–0.1449 | 0 | 22 | 17 | 35 | +| CH spawn 0.0299–0.0449 | 0 | | 2 | 35 | +| CH spawn 0.0449–0.0549 | 1 | | 1 | 19 | +| CH rear 0.0549–0.0649 | 2 | | 2 | 17 | + +The reviewer's "best single held-out CH WSG holds 6" was close but not exact: the densest +WSGs hold 5 (OWIK), 2 (LISR) and 5 (CARR). OWIK + BELA + KITR would reach 11 for CH +spawning 0.0299–0.0449, so the doc says "three to six more WSGs per step" rather than +"no small set". + +Operator decisions: BT only, with the widened held-out set; an underpowered step +leaves `default_tuned` as it is. + +## Phase 1 refactor is byte-identical + +`habitat_validate.R`, re-run with the absence taxa as data and the loaders sourced from +`habitat_validate_inputs.R`, with `knowledge` pinned at `508bf44` through `git archive`, +reproduces all six #283 CSVs byte for byte. The `knowledge` repo had moved (5 FISS site +files, about 11.8k lines), so an unpinned re-run would have differed for input reasons. +Removing the `BT,caught,Dolly Varden` row moves BT absences 1535 → 1539 (the data drives +the rule). + ## Errors Encountered | Error | Resolution | |-------|------------| +| `DISTINCT ON` probe gave staged CH counts differing by one between runs | aggregate per location with `bool_or`, as the validator dedups | diff --git a/planning/active/review-plan.md b/planning/active/review-plan.md new file mode 100644 index 00000000..16cb2db7 --- /dev/null +++ b/planning/active/review-plan.md @@ -0,0 +1,38 @@ +# Plan review — #284 step 5 (Plan agent, 2026-09-29) + +Read-only agent; findings returned as reply text and transcribed here with each one's disposition. + +## Blockers +- **B1 Power.** The held-out bands cannot reach n ≥ 10. Held-out locations: BT 7 / 1 / 0, CH 1 / 0 / 2 (the reviewer's FWA-gradient counts). **Confirmed**: the re-derivation gives BT 10 / 1 / 0, CH 0 / 1 / 2 (`data-raw/logs/habitat_score_284/power_windows.txt`). **Operator decision:** widen the BT held-out set (UARL, REVL, CLRH, LILL, BABL, BABR) and drop CH. +- **B2 "keep" semantics.** An underpowered first step would reset `default_tuned` to 0.1049. **Operator decision:** an underpowered step changes nothing; 0.1349 stands. +- **B3 CH spawning stage vs the UHC overlay.** The core could hold forced reaches. Moot once CH was dropped (BT has 0 UHC rows). The score script now stops if a scored species has forced reaches for the flag. + +## Gaps +- **G1** Re-persisting `default` in the variant loop would overwrite the recomputed access. **Already so:** the base variant is re-classified for its digest only and never persisted. +- **G2** Pass the working schema to persist explicitly. **Done.** +- **G3** `lnk_persist_init(species = cfg$species)`. **Done.** +- **G4** Must `load_all`. **Done** (`pkgload::load_all` at the top of both scripts). +- **G5** The knowledge repo moved since the #283 baseline. **Handled:** pinned at `508bf44` through `git archive`; byte-identical. +- **G6** Thin-bundle CSV fidelity. **Done:** the round-trip is proven byte-identical on default before any variant; the one-cell diff is asserted; `equals_bundle` is compared by md5. +- **G7** Variant schemas carry no DB provenance. **Done:** each bundle's provenance checksum is verified; the bundles and the stamp are committed. No per-variant `log` row (the variants are not pipeline runs). +- **G8** Recompute provenance and timeouts. **Done:** `log_recompute` rows plus the statement and lock timeouts. + +## Ordering +- **O1** The BULL pre-flight needs LARL and KOTL first (the guard). **Accepted:** the pre-flight is the first three base WSGs; the full run resumes past them. +- **O2** Recompute after all base WSGs. **Done.** +- **O3** Commit the rule after the power check. **Done:** the rule was revised with the counts before the commit. + +## Assumptions (verified by the reviewer) +- A1 re-classify is clean; A2 access is threshold-free; A4 a thin bundle outside `inst` works (set `name:`, own provenance); A5 the resolve order is downstream-first; A6 the band is buildable from `$observations`. +- **A3** A band is not purely the gradient window (clustering). **Done:** `bridge_band.csv` splits the band into in-window and connectivity-admitted. + +## Scope +- **S1** The closure costs about 55 % of the base run. Accepted at the gate. +- **S2** Variants classify every species. **Done:** variants classify BT only. +- **S3** Plan text drift (`tighter` → `step_from`; core = intersection). **Done:** task_plan revised; the nesting assertion is in the score script. + +## Acceptance +- **AC1** The access invariant was tautological. First fixed by comparing the working-derived access with the base's before the copy; code-check round 1 showed that comparison could never pass (a variant persists only its own species' access columns) and was not a threshold test either (classify and connect never rebuild access). The BULL pre-flight hit it at run time. **Dropped:** access is threshold-free by code reading (A2) and is copied from the base. +- **AC2** Rollup rounds to 0.01 km. Noted for the Phase 5 reconciliation tolerance. +- **AC3** The digest is defined as working long `streams_habitat` against working. **Done.** +- **AC4** Launch gate. **Done:** the build refuses uncommitted R/config/data changes unless `--allow-dirty`. diff --git a/research/habitat_thresholds.md b/research/habitat_thresholds.md index 2279c984..634dbcd6 100644 --- a/research/habitat_thresholds.md +++ b/research/habitat_thresholds.md @@ -281,25 +281,72 @@ command). Two findings from it change how this step is read: locations. Hold records out (by project, date or WSG) through the function's `observations` argument. -Run `default` and `default_tuned` on pilot WSGs with both species present and -observations to score against. The run decisions have to be stated before launch: - -- **config:** `default` and `default_tuned`, each writing its own schema - (`fresh_default`, `fresh_default_tuned`); -- **WSGs:** BULK and MORR (both species, already in `fresh_default`); UNTH and LNTH - (FISS snapshots and both species, but only in `fresh`, so they need a `default` run - first); -- the **closure** each resolves to, and `dams` / `mapping_code`. +### Scoring design, fixed 2026-09-29 before any run + +Every threshold variant is scored on the **same segmentation**. Each pilot WSG is prepared +once under `default` and then re-classified once per variant, because two full runs are not +bit-reproducible: the PSCIS tie in `lnk_pipeline_pscis_build.R` moves a segment. Access +does not depend on the habitat thresholds, so every variant carries `default`'s +`streams_access`. + +- **Variants** (`data-raw/habitat_score/variants.csv`): BT `rear_gradient_max` at 0.1249, + 0.1349 (`default_tuned`) and 0.1449, each differing from `default` in that one cell. +- **WSGs** (`data-raw/habitat_score/wsg_roles.csv`): + - **Held out:** ELKR, BULL, UARL, REVL, CLRH, LILL, BABL and BABR, none of them among the + 55 WSGs the step-1 percentiles came from. + - **In-sample:** PARS, KOTL, BULK and MORR. + - The twelve resolve to a 23-WSG drainage closure, which is modelled downstream-first so + that access sees the barriers below each pilot. Only the pilots are re-classified. +- **The band.** Each variant steps from its neighbour nearer `default` in the ladder + 0.1049 → 0.1249 → 0.1349 → 0.1449. The band is the set of segments whose stream-rearing + flag differs between the two, joined on `(id_segment, watershed_group_code)`. + - **The core** is the segments that are rearing under every variant of the ladder, which + is `default`'s rearing outside every band. + - **Observations** are the validator's: the #290 pooling from `default`'s tracker, buffer + 0. All stages count, since BT carries no life stage; that is the population the 0.1349 + was calibrated on. BT has no `user_habitat_classification` reaches, so no forced + habitat sits in the core. +- **Rule.** + - A band **is habitat** when its observations per km are at least 0.5 × the core's. + - It is read on the held-out WSGs, pooled, and needs **n ≥ 10** locations in the band. + - A step is taken when its band is habitat. The walk goes outward from `default` and + stops at the first step not taken. + - **An underpowered step (n < 10) changes nothing.** The step 1–4 verdict stands: + `default_tuned` keeps 0.1349, and the verdict is recorded as scored but underpowered. + - In-sample WSGs are reported and never decide. The literature veto stands. + +**Why BT only, and why these WSGs.** Before any band was computed, observation locations per +gradient window were counted with no density attached (`data-raw/logs/habitat_score_284/`, +FWA segment gradients, so upper bounds). The eight pilots first planned held out ELKR and +BULL for BT, and UNTH and LNTH for CH: + +| window | first held-out set | widened BT set | all 8 pilots | non-calibration WSGs (106 BT, 94 CH) | +|---|---|---|---|---| +| BT 0.1049–0.1249 | 10 | 43 | 66 | 95 | +| BT 0.1249–0.1349 | **1** | 33 | 15 | 45 | +| BT 0.1349–0.1449 | 0 | 22 | 17 | 35 | +| CH spawn-staged 0.0299–0.0449 | 0 | | 2 | 35 | +| CH spawn-staged 0.0449–0.0549 | 1 | | 1 | 19 | +| CH rear-staged 0.0549–0.0649 | 2 | | 2 | 17 | + +As first planned, the rule could not have decided five of the six steps. The held-out BT +set was widened to the densest non-calibration BT WSGs (UARL, REVL, CLRH, LILL, BABL and +BABR, beside ELKR and BULL), which gives the 43 / 33 / 22 above. + +CH was dropped. The CH locations outside the calibration set are spread thin: the +densest WSGs hold 5, 2 and 5 per step (OWIK, LISR and CARR). Reaching n ≥ 10 would +take three to six more WSGs per step, each with its own closure, on counts that are +upper bounds before the access, width and cluster filters. **The CH verdicts stay +"keep", unscored.** Operator's call, 2026-09-29, prompted by the plan review that found +the gap. The questions scoring must answer: 1. How much rearing length the BT gradient change adds, against the observation capture it buys. Test BT-only 0.1249 and the pooled pre-change / window value 0.1449 beside the - pooled 0.1349. Also test the CH values - retired by Method, Change 1 (CH spawning 0.0549, CH rearing 0.0649), since that change - was made after the numbers were seen; CH rearing 0.0649 is also what the window - gradient gives. + pooled 0.1349. The CH values retired by Method, Change 1 (CH spawning 0.0549, CH + rearing 0.0649) were to be tested too; they are unscorable (above). 2. How much of the newly admitted BT rearing sits above spawning, where the 0.05 downstream bridge decides whether it survives. 3. Whether spawning capture at 3–4.5 % justifies keeping the CH cutoff above the - literature's 3 %. + literature's 3 %. Unscorable: 0 held-out spawn-staged locations in that window. From fc1830487725fdbde6332147e848901249d60d06 Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 18:48:49 -0700 Subject: [PATCH 03/11] Add lnk_habitat_validate_band(): observation density on the segments a threshold step moves (#284) Compares two persisted runs that share segmentation and differ in one habitat threshold: the band (segments whose flag differs) against the core (segments with the flag in every schema of a ladder), as observation locations per km and their ratio. Joins on the full key, and stops when segmentation differs or a schema holds no habitat rows for a WSG, since either would turn into a false band. 37 tests; the guards are mutation-tested. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- NAMESPACE | 1 + R/lnk_habitat_validate_band.R | 283 ++++++++++++++++++ man/lnk_access.Rd | 1 + man/lnk_compare_mapping_code.Rd | 1 + man/lnk_compare_rollup.Rd | 1 + man/lnk_compare_wsg.Rd | 1 + man/lnk_habitat_validate.Rd | 1 + man/lnk_habitat_validate_band.Rd | 125 ++++++++ man/lnk_log_read.Rd | 1 + man/lnk_mapping_code.Rd | 1 + man/lnk_parity_annotate.Rd | 1 + man/lnk_rollup_wsg.Rd | 1 + .../testthat/test-lnk_habitat_validate_band.R | 185 ++++++++++++ 13 files changed, 603 insertions(+) create mode 100644 R/lnk_habitat_validate_band.R create mode 100644 man/lnk_habitat_validate_band.Rd create mode 100644 tests/testthat/test-lnk_habitat_validate_band.R diff --git a/NAMESPACE b/NAMESPACE index aff3c132..2e1d3471 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -22,6 +22,7 @@ export(lnk_config_verify) export(lnk_db_conn) export(lnk_fanout_judge) export(lnk_habitat_validate) +export(lnk_habitat_validate_band) export(lnk_inputs_verify) export(lnk_load) export(lnk_load_overrides) diff --git a/R/lnk_habitat_validate_band.R b/R/lnk_habitat_validate_band.R new file mode 100644 index 00000000..ae2c542d --- /dev/null +++ b/R/lnk_habitat_validate_band.R @@ -0,0 +1,283 @@ +#' Score the habitat one threshold step adds or removes +#' +#' Compares two persisted runs that share segmentation and differ in one +#' habitat threshold, and asks whether the segments the step moves (the +#' **band**) are used by fish about as often as habitat both runs agree on +#' (the **core**). It reports observations per km in each and their ratio, +#' which is the evidence for taking or refusing the step. +#' +#' For each watershed group and species: +#' - **Band, `added`:** segments `flag` in `schema` and not in `schema_ref`. +#' - **Band, `removed`:** segments `flag` in `schema_ref` and not in +#' `schema`. +#' - **Core:** segments `flag` in every schema of `schema_core`. Pass all +#' the schemas of a threshold ladder so the core is the habitat no step +#' in it moves. +#' +#' Observation locations are counted on the segment the validator attached +#' them to, so `observations` must come from [lnk_habitat_validate()] on +#' one of these schemas. +#' +#' @section Why segmentation must match: +#' Segments are compared on the full key `(id_segment, watershed_group_code)`, +#' which names the same stretch of stream in two schemas only when both were +#' broken identically. Two full pipeline runs are not guaranteed to be, so +#' prepare the network once and re-classify it per threshold. The function +#' compares an `id_segment` x `length_metre` digest of `streams` per WSG +#' across every schema it reads and stops when any differ. It also stops +#' when a schema holds no `streams_habitat_` rows for a WSG, which would +#' otherwise read as a WSG with no habitat. +#' +#' @param conn A [DBI::DBIConnection-class] object (from [lnk_db_conn()]). +#' @param aoi Character vector of watershed group codes, persisted in every +#' schema. +#' @param species Character vector of model species codes. Each must name +#' `.streams_habitat_` in every schema. +#' @param flag `"spawning"` or `"rearing"` (stream rearing, the flag the +#' rearing thresholds govern). +#' @param schema Persist schema with the step taken. +#' @param schema_ref Persist schema the step is taken from. +#' @param observations The `observations` data frame from +#' [lnk_habitat_validate()]. Uses `species_code`, `watershed_group_code`, +#' `id_segment`, `is_spawn` and `is_rear`. +#' @param stage Which locations count: `"any"` (all), `"spawn"` (spawn-staged) +#' or `"rear"` (rear-staged). +#' @param schema_core Character vector of persist schemas whose shared +#' `flag` segments form the core. Default `c(schema, schema_ref)`. +#' +#' @return A data frame, one row per `watershed_group_code` x `species_code` +#' x `direction` (`added`, `removed`), with `flag`, `stage`, `band_km`, +#' `n_band` (locations on band segments), `core_km`, `n_core`, +#' `density_band` and `density_core` (locations per km; `NA` when the km +#' is 0) and `density_ratio` (`density_band / density_core`; `NA` when +#' either is `NA` or the core density is 0). Counts are returned beside +#' the densities so rows can be pooled across WSGs by summing. +#' +#' @examples +#' \dontrun{ +#' conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, +#' user = "postgres", password = "postgres") +#' cfg <- lnk_config("default") +#' loaded <- lnk_load_overrides(cfg) +#' +#' # Observations as the validator attaches them to segments +#' v <- lnk_habitat_validate(conn, aoi = "BULL", cfg = cfg, loaded = loaded, +#' species = "BT", schema = "score284_default") +#' +#' # Is the rearing that BT rear_gradient_max 0.1249 -> 0.1349 adds used as +#' # often per km as the rearing every step agrees on? +#' lnk_habitat_validate_band( +#' conn, aoi = "BULL", species = "BT", flag = "rearing", +#' schema = "score284_bt_rear_0p1349", +#' schema_ref = "score284_bt_rear_0p1249", +#' observations = v$observations, stage = "any", +#' schema_core = c("score284_default", "score284_bt_rear_0p1249", +#' "score284_bt_rear_0p1349")) +#' } +#' +#' @family compare +#' @seealso [lnk_habitat_validate()] +#' @export +# nolint start: indentation_linter +lnk_habitat_validate_band <- function(conn, aoi, species, + flag = c("spawning", "rearing"), + schema, schema_ref, observations, + stage = c("any", "spawn", "rear"), + schema_core = c(schema, schema_ref)) { + flag <- match.arg(flag) + stage <- match.arg(stage) + is_schema <- function(x) { + is.character(x) && length(x) >= 1L && !anyNA(x) && + all(grepl("^[a-z_][a-z0-9_]*$", x)) + } + stopifnot( + inherits(conn, "DBIConnection"), + is.character(aoi), length(aoi) >= 1L, !anyNA(aoi), + all(grepl("^[A-Z]{3,5}$", aoi)), + is.character(species), length(species) >= 1L, !anyNA(species), + all(grepl("^[A-Za-z]+$", species)), + is_schema(schema), length(schema) == 1L, + is_schema(schema_ref), length(schema_ref) == 1L, + schema != schema_ref, + is_schema(schema_core), + is.data.frame(observations) + ) + cols_obs <- c("species_code", "watershed_group_code", "id_segment", + "is_spawn", "is_rear") + miss <- setdiff(cols_obs, names(observations)) + if (length(miss) > 0L) { + stop("observations is missing columns: ", paste(miss, collapse = ", "), + " (pass lnk_habitat_validate()$observations)", call. = FALSE) + } + aoi <- unique(aoi) + species <- unique(toupper(species)) + schemas <- unique(c(schema, schema_ref, schema_core)) + + .lnk_hvb_check_segmentation(conn, schemas, aoi) + .lnk_hvb_check_habitat(conn, schemas, aoi, species) + + o <- observations[!is.na(observations$id_segment) & + toupper(observations$species_code) %in% species & + observations$watershed_group_code %in% aoi, , + drop = FALSE] + keep <- switch(stage, + any = rep(TRUE, nrow(o)), + spawn = o$is_spawn %in% TRUE, + rear = o$is_rear %in% TRUE) + o <- o[keep, , drop = FALSE] + .lnk_hv_drop_temp(conn, "lnk_vb_obs") + DBI::dbWriteTable(conn, "lnk_vb_obs", data.frame( + species_code = toupper(o$species_code), + watershed_group_code = o$watershed_group_code, + id_segment = as.integer(o$id_segment), stringsAsFactors = FALSE), + temporary = TRUE, overwrite = TRUE) + + aoi_arr <- paste0("{", paste(aoi, collapse = ","), "}") + out <- do.call(rbind, lapply(species, function(sp) { + spl <- tolower(sp) + joins <- paste(vapply(seq_along(schemas), function(i) { + sprintf( + "LEFT JOIN %1$s.streams_habitat_%2$s h%3$d + ON h%3$d.id_segment = s.id_segment + AND h%3$d.watershed_group_code = s.watershed_group_code", + schemas[i], spl, i) + }, character(1)), collapse = "\n ") + f <- function(sch) { + sprintf("coalesce(h%d.%s, false)", match(sch, schemas), flag) + } + core <- paste(vapply(schema_core, f, character(1)), collapse = " AND ") + d <- DBI::dbGetQuery(conn, sprintf( + "WITH seg AS ( + SELECT s.watershed_group_code, s.id_segment, s.length_metre, + %3$s AND NOT %4$s AS added, + %4$s AND NOT %3$s AS removed, + %5$s AS core + FROM %1$s.streams s + %2$s + WHERE s.watershed_group_code = ANY($1)), + obs AS ( + SELECT watershed_group_code, id_segment, count(*)::int AS n + FROM pg_temp.lnk_vb_obs + WHERE species_code = $2 + GROUP BY 1, 2) + SELECT g.watershed_group_code, + coalesce(sum(g.length_metre) FILTER (WHERE g.added), 0) + / 1000 AS added_km, + coalesce(sum(o.n) FILTER (WHERE g.added), 0)::int AS added_n, + coalesce(sum(g.length_metre) FILTER (WHERE g.removed), 0) + / 1000 AS removed_km, + coalesce(sum(o.n) FILTER (WHERE g.removed), 0)::int AS removed_n, + coalesce(sum(g.length_metre) FILTER (WHERE g.core), 0) + / 1000 AS core_km, + coalesce(sum(o.n) FILTER (WHERE g.core), 0)::int AS core_n + FROM seg g + LEFT JOIN obs o + ON o.watershed_group_code = g.watershed_group_code + AND o.id_segment = g.id_segment + GROUP BY 1", + schema, joins, f(schema), f(schema_ref), core), + params = list(aoi_arr, sp)) + # A WSG with no streams rows still gets its rows, as zeros. + d <- merge(data.frame(watershed_group_code = aoi, + stringsAsFactors = FALSE), d, all.x = TRUE) + num <- setdiff(names(d), "watershed_group_code") + d[num] <- lapply(d[num], function(x) ifelse(is.na(x), 0, x)) + rbind( + data.frame(watershed_group_code = d$watershed_group_code, + species_code = sp, direction = "added", + band_km = d$added_km, n_band = as.integer(d$added_n), + core_km = d$core_km, n_core = as.integer(d$core_n), + stringsAsFactors = FALSE), + data.frame(watershed_group_code = d$watershed_group_code, + species_code = sp, direction = "removed", + band_km = d$removed_km, n_band = as.integer(d$removed_n), + core_km = d$core_km, n_core = as.integer(d$core_n), + stringsAsFactors = FALSE)) + })) + .lnk_hv_drop_temp(conn, "lnk_vb_obs") + + out <- cbind(out[1:3], data.frame(flag = flag, stage = stage, + stringsAsFactors = FALSE), out[-(1:3)]) + dens <- .lnk_hvb_density(out$n_band, out$band_km, out$n_core, out$core_km) + out <- cbind(out, dens) + out <- out[order(out$species_code, out$watershed_group_code, + out$direction), ] + rownames(out) <- NULL + out +} + +#' Observations per km and their ratio; NA where a km or the core density +#' is 0, never 0 or Inf. +#' @noRd +.lnk_hvb_density <- function(n_band, band_km, n_core, core_km) { + per_km <- function(n, km) ifelse(km > 0, n / km, NA_real_) + db <- per_km(n_band, band_km) + dc <- per_km(n_core, core_km) + data.frame(density_band = db, density_core = dc, + density_ratio = ifelse(!is.na(dc) & dc > 0, db / dc, NA_real_)) +} + +#' Stop unless every schema holds habitat rows for every species x WSG. +#' +#' A schema can carry an empty `streams_habitat_` (persist creates every +#' species' table; a run may fill only some), which a LEFT JOIN would read as +#' "no habitat" and turn into a band or a core of zero. +#' @noRd +.lnk_hvb_check_habitat <- function(conn, schemas, aoi, species) { + aoi_arr <- paste0("{", paste(aoi, collapse = ","), "}") + miss <- character(0) + for (s in schemas) { + for (sp in species) { + have <- DBI::dbGetQuery(conn, sprintf( + "SELECT DISTINCT watershed_group_code FROM %s.streams_habitat_%s + WHERE watershed_group_code = ANY($1)", s, tolower(sp)), + params = list(aoi_arr))$watershed_group_code + gone <- setdiff(aoi, have) + if (length(gone) > 0L) { + miss <- c(miss, paste0(s, ".streams_habitat_", tolower(sp), ":", gone)) + } + } + } + if (length(miss) > 0L) { + stop("no habitat rows for: ", paste(miss, collapse = ", "), + ". Pass only WSGs where every schema modelled the species.", + call. = FALSE) + } + invisible(TRUE) +} + +#' Stop unless every schema carries the same segments per WSG. +#' @noRd +.lnk_hvb_check_segmentation <- function(conn, schemas, aoi) { + aoi_arr <- paste0("{", paste(aoi, collapse = ","), "}") + dg <- do.call(rbind, lapply(schemas, function(s) { + d <- DBI::dbGetQuery(conn, sprintf( + "SELECT watershed_group_code, + md5(string_agg(id_segment::text || ':' || + round(length_metre::numeric, 3)::text, '|' + ORDER BY id_segment)) AS digest + FROM %s.streams + WHERE watershed_group_code = ANY($1) + GROUP BY 1", s), params = list(aoi_arr)) + d <- merge(data.frame(watershed_group_code = aoi, + stringsAsFactors = FALSE), d, all.x = TRUE) + d$schema <- s + d + })) + empty <- dg[is.na(dg$digest), , drop = FALSE] + if (nrow(empty) > 0L) { + stop("no streams for: ", + paste(unique(paste0(empty$schema, ":", empty$watershed_group_code)), + collapse = ", "), call. = FALSE) + } + n_distinct <- tapply(dg$digest, dg$watershed_group_code, + function(x) length(unique(x))) + bad <- names(n_distinct)[n_distinct > 1L] + if (length(bad) > 0L) { + stop("segmentation differs between ", paste(schemas, collapse = ", "), + " in: ", paste(bad, collapse = ", "), + ". Compare runs that share one prepared network.", call. = FALSE) + } + invisible(TRUE) +} +# nolint end: indentation_linter diff --git a/man/lnk_access.Rd b/man/lnk_access.Rd index 8e579a21..46375a87 100644 --- a/man/lnk_access.Rd +++ b/man/lnk_access.Rd @@ -140,6 +140,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, diff --git a/man/lnk_compare_mapping_code.Rd b/man/lnk_compare_mapping_code.Rd index 564042da..90532eb7 100644 --- a/man/lnk_compare_mapping_code.Rd +++ b/man/lnk_compare_mapping_code.Rd @@ -103,6 +103,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, diff --git a/man/lnk_compare_rollup.Rd b/man/lnk_compare_rollup.Rd index 5389d5b9..951ae2ea 100644 --- a/man/lnk_compare_rollup.Rd +++ b/man/lnk_compare_rollup.Rd @@ -97,6 +97,7 @@ Other compare: \code{\link{lnk_compare_mapping_code}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, diff --git a/man/lnk_compare_wsg.Rd b/man/lnk_compare_wsg.Rd index 0f5c2338..d0897eea 100644 --- a/man/lnk_compare_wsg.Rd +++ b/man/lnk_compare_wsg.Rd @@ -153,6 +153,7 @@ Other compare: \code{\link{lnk_compare_mapping_code}()}, \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, diff --git a/man/lnk_habitat_validate.Rd b/man/lnk_habitat_validate.Rd index e9d854a2..31df438c 100644 --- a/man/lnk_habitat_validate.Rd +++ b/man/lnk_habitat_validate.Rd @@ -262,6 +262,7 @@ Other compare: \code{\link{lnk_compare_mapping_code}()}, \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, diff --git a/man/lnk_habitat_validate_band.Rd b/man/lnk_habitat_validate_band.Rd new file mode 100644 index 00000000..ae00e268 --- /dev/null +++ b/man/lnk_habitat_validate_band.Rd @@ -0,0 +1,125 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/lnk_habitat_validate_band.R +\name{lnk_habitat_validate_band} +\alias{lnk_habitat_validate_band} +\title{Score the habitat one threshold step adds or removes} +\usage{ +lnk_habitat_validate_band( + conn, + aoi, + species, + flag = c("spawning", "rearing"), + schema, + schema_ref, + observations, + stage = c("any", "spawn", "rear"), + schema_core = c(schema, schema_ref) +) +} +\arguments{ +\item{conn}{A \link[DBI:DBIConnection-class]{DBI::DBIConnection} object (from \code{\link[=lnk_db_conn]{lnk_db_conn()}}).} + +\item{aoi}{Character vector of watershed group codes, persisted in every +schema.} + +\item{species}{Character vector of model species codes. Each must name +\verb{.streams_habitat_} in every schema.} + +\item{flag}{\code{"spawning"} or \code{"rearing"} (stream rearing, the flag the +rearing thresholds govern).} + +\item{schema}{Persist schema with the step taken.} + +\item{schema_ref}{Persist schema the step is taken from.} + +\item{observations}{The \code{observations} data frame from +\code{\link[=lnk_habitat_validate]{lnk_habitat_validate()}}. Uses \code{species_code}, \code{watershed_group_code}, +\code{id_segment}, \code{is_spawn} and \code{is_rear}.} + +\item{stage}{Which locations count: \code{"any"} (all), \code{"spawn"} (spawn-staged) +or \code{"rear"} (rear-staged).} + +\item{schema_core}{Character vector of persist schemas whose shared +\code{flag} segments form the core. Default \code{c(schema, schema_ref)}.} +} +\value{ +A data frame, one row per \code{watershed_group_code} x \code{species_code} +x \code{direction} (\code{added}, \code{removed}), with \code{flag}, \code{stage}, \code{band_km}, +\code{n_band} (locations on band segments), \code{core_km}, \code{n_core}, +\code{density_band} and \code{density_core} (locations per km; \code{NA} when the km +is 0) and \code{density_ratio} (\code{density_band / density_core}; \code{NA} when +either is \code{NA} or the core density is 0). Counts are returned beside +the densities so rows can be pooled across WSGs by summing. +} +\description{ +Compares two persisted runs that share segmentation and differ in one +habitat threshold, and asks whether the segments the step moves (the +\strong{band}) are used by fish about as often as habitat both runs agree on +(the \strong{core}). It reports observations per km in each and their ratio, +which is the evidence for taking or refusing the step. +} +\details{ +For each watershed group and species: +\itemize{ +\item \strong{Band, \code{added}:} segments \code{flag} in \code{schema} and not in \code{schema_ref}. +\item \strong{Band, \code{removed}:} segments \code{flag} in \code{schema_ref} and not in +\code{schema}. +\item \strong{Core:} segments \code{flag} in every schema of \code{schema_core}. Pass all +the schemas of a threshold ladder so the core is the habitat no step +in it moves. +} + +Observation locations are counted on the segment the validator attached +them to, so \code{observations} must come from \code{\link[=lnk_habitat_validate]{lnk_habitat_validate()}} on +one of these schemas. +} +\section{Why segmentation must match}{ + +Segments are compared on the full key \verb{(id_segment, watershed_group_code)}, +which names the same stretch of stream in two schemas only when both were +broken identically. Two full pipeline runs are not guaranteed to be, so +prepare the network once and re-classify it per threshold. The function +compares an \code{id_segment} x \code{length_metre} digest of \code{streams} per WSG +across every schema it reads and stops when any differ. It also stops +when a schema holds no \verb{streams_habitat_} rows for a WSG, which would +otherwise read as a WSG with no habitat. +} + +\examples{ +\dontrun{ +conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, + user = "postgres", password = "postgres") +cfg <- lnk_config("default") +loaded <- lnk_load_overrides(cfg) + +# Observations as the validator attaches them to segments +v <- lnk_habitat_validate(conn, aoi = "BULL", cfg = cfg, loaded = loaded, + species = "BT", schema = "score284_default") + +# Is the rearing that BT rear_gradient_max 0.1249 -> 0.1349 adds used as +# often per km as the rearing every step agrees on? +lnk_habitat_validate_band( + conn, aoi = "BULL", species = "BT", flag = "rearing", + schema = "score284_bt_rear_0p1349", + schema_ref = "score284_bt_rear_0p1249", + observations = v$observations, stage = "any", + schema_core = c("score284_default", "score284_bt_rear_0p1249", + "score284_bt_rear_0p1349")) +} + +} +\seealso{ +\code{\link[=lnk_habitat_validate]{lnk_habitat_validate()}} + +Other compare: +\code{\link{lnk_access}()}, +\code{\link{lnk_compare_mapping_code}()}, +\code{\link{lnk_compare_rollup}()}, +\code{\link{lnk_compare_wsg}()}, +\code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_log_read}()}, +\code{\link{lnk_mapping_code}()}, +\code{\link{lnk_parity_annotate}()}, +\code{\link{lnk_rollup_wsg}()} +} +\concept{compare} diff --git a/man/lnk_log_read.Rd b/man/lnk_log_read.Rd index 90226d02..f8c2111c 100644 --- a/man/lnk_log_read.Rd +++ b/man/lnk_log_read.Rd @@ -78,6 +78,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()}, \code{\link{lnk_rollup_wsg}()} diff --git a/man/lnk_mapping_code.Rd b/man/lnk_mapping_code.Rd index c48c0d8d..68b15056 100644 --- a/man/lnk_mapping_code.Rd +++ b/man/lnk_mapping_code.Rd @@ -126,6 +126,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_parity_annotate}()}, \code{\link{lnk_rollup_wsg}()} diff --git a/man/lnk_parity_annotate.Rd b/man/lnk_parity_annotate.Rd index 1d3c5d52..006a940d 100644 --- a/man/lnk_parity_annotate.Rd +++ b/man/lnk_parity_annotate.Rd @@ -65,6 +65,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_rollup_wsg}()} diff --git a/man/lnk_rollup_wsg.Rd b/man/lnk_rollup_wsg.Rd index 416f61d7..41a914f8 100644 --- a/man/lnk_rollup_wsg.Rd +++ b/man/lnk_rollup_wsg.Rd @@ -106,6 +106,7 @@ Other compare: \code{\link{lnk_compare_rollup}()}, \code{\link{lnk_compare_wsg}()}, \code{\link{lnk_habitat_validate}()}, +\code{\link{lnk_habitat_validate_band}()}, \code{\link{lnk_log_read}()}, \code{\link{lnk_mapping_code}()}, \code{\link{lnk_parity_annotate}()} diff --git a/tests/testthat/test-lnk_habitat_validate_band.R b/tests/testthat/test-lnk_habitat_validate_band.R new file mode 100644 index 00000000..f23f6267 --- /dev/null +++ b/tests/testthat/test-lnk_habitat_validate_band.R @@ -0,0 +1,185 @@ +# lnk_habitat_validate_band() — observation density on the segments a +# threshold step moves. +# Closing parens sit on the last argument line, as in the other test files. +# nolint start: indentation_linter + +test_that(".lnk_hvb_density returns NA, never 0 or Inf, on an empty side", { + d <- link:::.lnk_hvb_density(n_band = c(2, 0, 3, 1), band_km = c(0.2, 0, 0.1, 0.1), + n_core = c(2, 2, 0, 1), core_km = c(0.1, 0.1, 0.1, 0)) + expect_equal(d$density_band, c(10, NA, 30, 10)) + expect_equal(d$density_core, c(20, 20, 0, NA)) + expect_equal(d$density_ratio, c(0.5, NA, NA, NA)) +}) + +# -- DB fixture -------------------------------------------------------------- +# Three schemas share one network: ref (the step's origin), new (the step +# taken) and core (a third ladder member). AAAA and BBBB reuse id_segment +# 1-4, so a bare id_segment join would read BBBB's rearing for AAAA. +# +# AAAA stream rearing: seg 1 seg 2 seg 3 seg 4 seg 5 +# ref x x - - - +# new x - x x - +# core x x x x - +# -> added {3, 4} 0.2 km; removed {2} 0.1 km; core (all three) {1} 0.1 km. +# BBBB: segs 3 and 4 rearing everywhere, so nothing moves. +local_band_fixture <- function(conn, env = parent.frame()) { + ss <- c(ref = "zz_lnk_band_ref", new = "zz_lnk_band_new", + core = "zz_lnk_band_core", odd = "zz_lnk_band_odd") + for (s in ss) { + DBI::dbExecute(conn, sprintf("DROP SCHEMA IF EXISTS %s CASCADE", s)) + DBI::dbExecute(conn, sprintf("CREATE SCHEMA %s", s)) + } + withr::defer(for (s in ss) { + try(DBI::dbExecute(conn, sprintf("DROP SCHEMA %s CASCADE", s)), + silent = TRUE) + }, envir = env) + wsg <- c(rep("AAAA", 5), rep("BBBB", 4)) + ids <- c(1:5, 1:4) + streams <- data.frame(id_segment = ids, watershed_group_code = wsg, + length_metre = 100) + rear <- list( + ref = c(TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE), + new = c(TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE), + core = c(TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE), + odd = c(TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE)) + for (k in names(ss)) { + st <- streams + # `odd` was broken differently in AAAA: its segment 5 is longer. + if (k == "odd") st$length_metre[5] <- 150 + DBI::dbWriteTable(conn, DBI::Id(schema = ss[[k]], table = "streams"), st) + DBI::dbWriteTable(conn, DBI::Id(schema = ss[[k]], + table = "streams_habitat_bt"), + data.frame(id_segment = ids, watershed_group_code = wsg, + spawning = FALSE, rearing = rear[[k]])) + } + as.list(ss) +} + +band_obs <- function() { + data.frame( + species_code = c("BT", "BT", "BT", "BT", "BT", "BT", "BT", "CH", "BT"), + watershed_group_code = c("AAAA", "AAAA", "AAAA", "AAAA", "AAAA", "AAAA", + "BBBB", "AAAA", "AAAA"), + id_segment = c(1L, 1L, 3L, 4L, 2L, 5L, 3L, 3L, NA), + is_spawn = c(FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE), + is_rear = c(TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE), + stringsAsFactors = FALSE) +} + +band_conn <- function(env = parent.frame()) { + skip_if_no_db() + conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, + user = "postgres", password = "postgres") + withr::defer(DBI::dbDisconnect(conn), envir = env) + conn +} + +run_band <- function(conn, ss, ...) { + lnk_habitat_validate_band(conn, aoi = c("AAAA", "BBBB"), species = "bt", + flag = "rearing", schema = ss$new, + schema_ref = ss$ref, observations = band_obs(), + ...) +} + +row_of <- function(b, wsg, dir) { + b[b$watershed_group_code == wsg & b$direction == dir, ] +} + +test_that("lnk_habitat_validate_band counts the band and core on the full key", { + conn <- band_conn() + ss <- local_band_fixture(conn) + b <- run_band(conn, ss, stage = "any", + schema_core = c(ss$ref, ss$new, ss$core)) + + expect_identical(nrow(b), 4L) + expect_identical(unique(b$species_code), "BT") + expect_identical(unique(b$flag), "rearing") + expect_identical(unique(b$stage), "any") + + a <- row_of(b, "AAAA", "added") + expect_equal(a$band_km, 0.2) + # seg 3 and seg 4; the CH record on seg 3 and the unattached one do not count + expect_identical(a$n_band, 2L) + expect_equal(a$core_km, 0.1) + expect_identical(a$n_core, 2L) + expect_equal(a$density_band, 10) + expect_equal(a$density_core, 20) + expect_equal(a$density_ratio, 0.5) + + r <- row_of(b, "AAAA", "removed") + expect_equal(r$band_km, 0.1) + expect_identical(r$n_band, 1L) + expect_equal(r$density_ratio, 0.5) + + # BBBB's segs 3 and 4 are rearing in every schema: a bare id_segment join + # would have made AAAA's segs 3 and 4 core and left no added band. + bb <- row_of(b, "BBBB", "added") + expect_equal(bb$band_km, 0) + expect_identical(bb$n_band, 0L) + expect_equal(bb$core_km, 0.2) + expect_identical(bb$n_core, 1L) + expect_true(is.na(bb$density_band)) + expect_true(is.na(bb$density_ratio)) +}) + +test_that("lnk_habitat_validate_band's default core is the pair's shared habitat", { + conn <- band_conn() + ss <- local_band_fixture(conn) + b <- run_band(conn, ss, stage = "any") + # ref and new share seg 1 only in AAAA, the same core as the ladder here + expect_equal(row_of(b, "AAAA", "added")$core_km, 0.1) + expect_identical(row_of(b, "AAAA", "added")$n_core, 2L) +}) + +test_that("lnk_habitat_validate_band counts only the requested stage", { + conn <- band_conn() + ss <- local_band_fixture(conn) + rr <- run_band(conn, ss, stage = "rear") + # rear-staged: seg 1 (one of two), seg 2; none on segs 3 and 4 + expect_identical(row_of(rr, "AAAA", "added")$n_band, 0L) + expect_equal(row_of(rr, "AAAA", "added")$density_ratio, 0) + expect_identical(row_of(rr, "AAAA", "removed")$n_band, 1L) + expect_identical(row_of(rr, "AAAA", "removed")$n_core, 1L) + expect_equal(row_of(rr, "AAAA", "removed")$density_ratio, 1) + + sp <- run_band(conn, ss, stage = "spawn") + expect_identical(row_of(sp, "AAAA", "added")$n_band, 1L) + expect_identical(row_of(sp, "AAAA", "added")$n_core, 0L) + expect_true(is.na(row_of(sp, "AAAA", "added")$density_ratio)) +}) + +test_that("lnk_habitat_validate_band stops when segmentation differs", { + conn <- band_conn() + ss <- local_band_fixture(conn) + expect_error(run_band(conn, ss, schema_core = c(ss$ref, ss$new, ss$odd)), + "segmentation differs .* in: AAAA\\. Compare") + expect_error( + lnk_habitat_validate_band(conn, aoi = "CCCC", species = "BT", + flag = "rearing", schema = ss$new, + schema_ref = ss$ref, observations = band_obs()), + "no streams for: zz_lnk_band_new:CCCC") +}) + +test_that("lnk_habitat_validate_band stops on a schema that modelled no habitat for a WSG", { + conn <- band_conn() + ss <- local_band_fixture(conn) + # An empty table reads as no habitat: BBBB would become a removed band. + DBI::dbExecute(conn, sprintf( + "DELETE FROM %s.streams_habitat_bt WHERE watershed_group_code = 'BBBB'", + ss$new)) + expect_error(run_band(conn, ss), + "no habitat rows for: zz_lnk_band_new\\.streams_habitat_bt:BBBB") +}) + +test_that("lnk_habitat_validate_band rejects an observations frame without segments", { + conn <- band_conn() + ss <- local_band_fixture(conn) + o <- band_obs() + o$id_segment <- NULL + expect_error( + lnk_habitat_validate_band(conn, aoi = "AAAA", species = "BT", + flag = "rearing", schema = ss$new, + schema_ref = ss$ref, observations = o), + "missing columns: id_segment") +}) +# nolint end From a11a0016276da0293484bfc6a77afafafa76ea82 Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 18:48:49 -0700 Subject: [PATCH 04/11] Variant build and scoring harness for #284 step 5 (#284) habitat_variants_build.R models the drainage closure once under default (downstream-first), keeps the focal WSGs' working schemas, and re-classifies each threshold variant on that shared network into score284_. The invariants: identical segmentation, access copied from the base, and a default re-classify that reproduces the base digest. Each variant is a thin bundle with its own provenance checksum; built.csv records per variant x WSG which bundle a schema came from, and resume reuses only clean, same-commit bases. habitat_variants_score.R validates every schema, computes the ladder bands with lnk_habitat_validate_band(), and applies the fixed rule once per ladder (an underpowered step changes nothing). Code-check ran five rounds plus an enumeration; see planning/active/review-*.md. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/habitat_variants_build.R | 527 +++++++++++++++++++++++++ data-raw/habitat_variants_score.R | 546 ++++++++++++++++++++++++++ planning/active/progress.md | 6 + planning/active/review-enumeration.md | 20 + planning/active/review-round1.md | 34 ++ planning/active/review-round2.md | 62 +++ planning/active/review-round3.md | 100 +++++ planning/active/review-round4.md | 89 +++++ planning/active/review-round5.md | 128 ++++++ planning/active/task_plan.md | 88 +++-- 10 files changed, 1560 insertions(+), 40 deletions(-) create mode 100644 data-raw/habitat_variants_build.R create mode 100644 data-raw/habitat_variants_score.R create mode 100644 planning/active/review-enumeration.md create mode 100644 planning/active/review-round1.md create mode 100644 planning/active/review-round2.md create mode 100644 planning/active/review-round3.md create mode 100644 planning/active/review-round4.md create mode 100644 planning/active/review-round5.md diff --git a/data-raw/habitat_variants_build.R b/data-raw/habitat_variants_build.R new file mode 100644 index 00000000..e3ee1533 --- /dev/null +++ b/data-raw/habitat_variants_build.R @@ -0,0 +1,527 @@ +#!/usr/bin/env Rscript +# habitat_variants_build.R — model habitat-threshold variants on ONE shared +# segmentation, for scoring against fish observations (link#284 step 5). +# +# Two full pipeline runs are not bit-reproducible (the PSCIS tie in +# lnk_pipeline_pscis_build.R moves a segment), so variants are never run +# independently. Instead: +# +# base lnk_pipeline_run() for `default` over the drainage closure of +# the focal WSGs, downstream first, into default. The +# focal WSGs keep their working schema (working_score_), and +# their access is re-settled against the whole closure +# (lnk_access(merge = TRUE), as wsg_recompute_one.R does). +# variants per variant x focal WSG: re-run lnk_pipeline_classify() + +# lnk_pipeline_connect() on that working schema with the +# variant's thresholds, persist into , and copy +# streams_access from default (access does not read the +# habitat thresholds). +# +# Each variant is a thin bundle generated from --variants (one cell of +# `default`'s parameters_habitat_thresholds.csv changed) into +# /bundles//, and loaded by path, so a scored schema always has +# a bundle on disk that says exactly what produced it. +# +# Invariants, asserted (the run stops on the first failure): +# - every variant schema carries the same streams as default, per +# focal WSG (streams_access is copied from it, and checked after the copy); +# - re-classifying with `default`'s own thresholds reproduces the base +# run's working streams_habitat digest, so the re-classify path adds no +# difference of its own; +# - a variant marked `equals_bundle` has exactly that bundle's thresholds. +# +# Rscript data-raw/habitat_variants_build.R \ +# [--variants=data-raw/habitat_score/variants.csv] \ +# [--roles=data-raw/habitat_score/wsg_roles.csv] \ +# [--wsgs=BULL] focal subset (pre-flight); default: every +# WSG in --roles +# [--only=default,x] variant subset; default: all +# [--step=all|base|variants] [--prefix=score284_] +# [--out=data-raw/logs/habitat_score_284] [--allow-dirty] +# +# Resumable: a base WSG whose streams_access is already in default +# (and, if focal, whose working schema survives) is not re-run. Variant passes +# always re-run; a variant classifies only its own species. +# +# Local docker fwapg (:5432) only. Launch long runs detached, and do not touch +# the repo while one runs: pkgload::load_all() and lnk_stamp read it. + +suppressPackageStartupMessages({ + pkgload::load_all(quiet = TRUE) + library(DBI) +}) + +opt <- function(name, default = NULL) { + a <- grep(paste0("^--", name, "="), commandArgs(trailingOnly = TRUE), + value = TRUE) + if (length(a) == 0L) return(default) + sub(paste0("^--", name, "="), "", a[length(a)]) +} +split_csv <- function(x) { + if (is.null(x)) return(character(0)) + v <- trimws(strsplit(x, ",")[[1]]) + v[nzchar(v)] +} +say <- function(...) { + message(format(Sys.time(), "%H:%M:%S "), sprintf(...)) +} + +path_variants <- opt("variants", file.path("data-raw", "habitat_score", + "variants.csv")) +path_roles <- opt("roles", file.path("data-raw", "habitat_score", + "wsg_roles.csv")) +step <- opt("step", "all") +if (!step %in% c("all", "base", "variants")) { + stop("--step must be all, base or variants", call. = FALSE) +} +prefix <- opt("prefix", "score284_") +if (!grepl("^[a-z][a-z0-9_]*_$", prefix)) { + stop("--prefix must be lower-case and end in '_'", call. = FALSE) +} +dir_out <- opt("out", file.path("data-raw", "logs", "habitat_score_284")) + +# A scored schema must be traceable to committed code and inputs. +dirty <- system(paste("git status --porcelain -- R inst/extdata/configs", + "data-raw/habitat_score data-raw/habitat_variants_build.R"), + intern = TRUE) +head_sha <- system("git rev-parse --short HEAD", intern = TRUE) +if (length(dirty) > 0L && !"--allow-dirty" %in% commandArgs(TRUE)) { + stop("uncommitted changes the build depends on (--allow-dirty to proceed):\n", + paste(dirty, collapse = "\n"), call. = FALSE) +} + +variants <- utils::read.csv(path_variants, colClasses = "character", + na.strings = "") +roles <- utils::read.csv(path_roles, colClasses = "character") +stopifnot( + identical(names(variants), c("variant", "species_code", "column", "value", + "flag", "obs_stage", "step_from", + "equals_bundle")), + !anyDuplicated(variants$variant), + all(grepl("^[a-z][a-z0-9_]*$", variants$variant)), + sum(is.na(variants$column)) == 1L, + identical(names(roles), c("watershed_group_code", "species_code", "role")), + all(roles$role %in% c("held_out", "in_sample")) +) +base_variant <- variants$variant[is.na(variants$column)] +# The ladders must be well formed before anything runs: every step_from names +# a listed variant, and each variant is stepped from by at most one other, so +# every ladder is one chain out from the base (no cycle, no branch below it). +local({ + steps_from <- variants$step_from[!is.na(variants$column)] + if (!all(steps_from %in% variants$variant)) { + stop("step_from names no listed variant: ", + paste(setdiff(steps_from, variants$variant), collapse = ", "), + call. = FALSE) + } + below <- steps_from[steps_from != base_variant] + if (anyDuplicated(below)) { + stop("a ladder branches below the base at: ", + paste(unique(below[duplicated(below)]), collapse = ", "), + call. = FALSE) + } + for (v in variants$variant) { + seen <- character(0) + while (!identical(v, base_variant)) { + if (v %in% seen) stop("step_from cycle through ", v, call. = FALSE) + seen <- c(seen, v) + v <- variants$step_from[variants$variant == v] + } + } +}) +only <- split_csv(opt("only")) +if (length(only) > 0L) { + bad <- setdiff(only, variants$variant) + if (length(bad) > 0L) stop("--only names no variant: ", paste(bad, collapse = ", "), + call. = FALSE) +} +focal <- toupper(split_csv(opt("wsgs"))) +if (length(focal) == 0L) focal <- unique(roles$watershed_group_code) +if (length(setdiff(focal, roles$watershed_group_code)) > 0L) { + stop("--wsgs outside --roles: ", + paste(setdiff(focal, roles$watershed_group_code), collapse = ", "), + call. = FALSE) +} +schema_of <- function(v) paste0(prefix, v) +working_of <- function(w) paste0("working_score_", tolower(w)) + +conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, + user = "postgres", password = "postgres") +fs::dir_create(file.path(dir_out, "bundles")) + +# -- the base bundle, and one thin bundle per variant -------------------------------- +cfg_default <- lnk_config("default") +cfg_default$pipeline$schema <- schema_of(base_variant) +loaded <- suppressWarnings(lnk_load_overrides(cfg_default)) +path_thr_default <- cfg_default$files$parameters_habitat_thresholds$path +thr_default <- utils::read.csv(path_thr_default, colClasses = "character") +# Write a thresholds table in the shipped CSVs' shape: header and text columns +# quoted, numbers bare, NA bare. Proven on `default` itself before any variant +# is written, so a variant bundle differs from `default` in its one cell only. +write_thresholds <- function(thr, path) { + utils::write.csv(thr, path, row.names = FALSE, na = "NA", + quote = which(names(thr) == "species_code" | + grepl("_edge_types$", names(thr)))) +} +local({ + tmp <- tempfile(fileext = ".csv") + write_thresholds(thr_default, tmp) + if (!identical(unname(tools::md5sum(tmp)), + unname(tools::md5sum(path_thr_default)))) { + stop("re-writing default's thresholds does not reproduce ", + path_thr_default, " byte for byte", call. = FALSE) + } + unlink(tmp) +}) + +bundle_dir <- function(v) file.path(dir_out, "bundles", v) +write_bundle <- function(r) { + thr <- thr_default + if (!r$column %in% names(thr)) { + stop("variant ", r$variant, ": no column ", r$column, call. = FALSE) + } + i <- which(thr$species_code == r$species_code) + if (length(i) != 1L) { + stop("variant ", r$variant, ": species ", r$species_code, + " not in default's thresholds", call. = FALSE) + } + if (identical(thr[[r$column]][i], r$value)) { + stop("variant ", r$variant, " equals default: ", r$column, " is already ", + r$value, call. = FALSE) + } + thr[[r$column]][i] <- r$value + n_diff <- sum(mapply(function(a, b) { + sum(!((a == b) %in% TRUE) & !(is.na(a) & is.na(b))) + }, thr, thr_default)) + if (n_diff != 1L) { + stop("variant ", r$variant, " differs from default in ", n_diff, + " cells, not 1", call. = FALSE) + } + d <- bundle_dir(r$variant) + fs::dir_create(d) + path_thr <- file.path(d, "parameters_habitat_thresholds.csv") + write_thresholds(thr, path_thr) + yaml::write_yaml(list( + name = r$variant, + description = sprintf(paste( + "link#284 step 5 scoring variant, generated by", + "data-raw/habitat_variants_build.R from %s: `default` with %s %s", + "%s -> %s."), basename(path_variants), r$species_code, r$column, + thr_default[[r$column]][i], r$value), + extends = "default", + files = list(parameters_habitat_thresholds = list( + path = "parameters_habitat_thresholds.csv")), + pipeline = list(schema = schema_of(r$variant)), + # Its own entry, or the inherited one would verify default's copy. + provenance = list(parameters_habitat_thresholds.csv = list( + source = sprintf("link (generated from configs/default; %s row %s)", + basename(path_variants), r$variant), + checksum = paste0("sha256:", digest::digest(file = path_thr, + algo = "sha256"))))), + file.path(d, "config.yaml")) + cfg <- lnk_config(normalizePath(d)) + ver <- lnk_config_verify(cfg) + ver <- ver[ver$file == "parameters_habitat_thresholds.csv", ] + if (nrow(ver) != 1L || isTRUE(ver$byte_drift)) { + stop("variant ", r$variant, ": its thresholds do not verify against ", + "its own provenance", call. = FALSE) + } + if (!is.na(r$equals_bundle)) { + a <- tools::md5sum(cfg$files$parameters_habitat_thresholds$path) + b <- tools::md5sum( + lnk_config(r$equals_bundle)$files$parameters_habitat_thresholds$path) + if (!identical(unname(a), unname(b))) { + stop("variant ", r$variant, " is declared equal to bundle ", + r$equals_bundle, " but its thresholds differ", call. = FALSE) + } + } + cfg +} +# The base re-classify is what licenses every variant (its digest check), so +# it runs in every variants pass, --only or not. +run_variants <- unique(c(base_variant, + if (length(only) > 0L) only else variants$variant)) +# A bundle is written when its variant is built (run_variant()), and +# built.csv records the bundle sha each schema was built from once that +# schema's checks pass; the score stops when the two disagree. +cfgs <- list() +cfgs[[base_variant]] <- cfg_default +path_built <- file.path(dir_out, "built.csv") +# One row per variant x WSG, replaced only for the pair just built, so a +# build over a WSG subset cannot vouch for the WSGs it did not touch. +record_built <- function(v, w) { + row <- data.frame( + variant = v, watershed_group_code = w, schema = schema_of(v), + thresholds_sha256 = digest::digest( + file = cfgs[[v]]$files$parameters_habitat_thresholds$path, + algo = "sha256"), + link_head = head_sha, dirty = length(dirty) > 0L, + built_at = format(Sys.time(), "%Y-%m-%d %H:%M:%S %Z")) + old <- if (file.exists(path_built)) { + utils::read.csv(path_built, colClasses = "character") + } else { + NULL + } + keep <- !(old$variant == v & old$watershed_group_code == w) + utils::write.csv(rbind(old[keep, , drop = FALSE], row), path_built, + row.names = FALSE) +} + +# -- digests: the invariants ------------------------------------------------------------ +digest_sql <- list( + streams = "SELECT md5(string_agg(id_segment::text || ':' || + round(length_metre::numeric, 3)::text, '|' ORDER BY id_segment)) + FROM %s.streams WHERE watershed_group_code = $1", + streams_access = "SELECT md5(string_agg(t::text, '|' ORDER BY t.id_segment)) + FROM (SELECT * FROM %s.streams_access + WHERE watershed_group_code = $1) t") +digest_of <- function(schema, table, wsg) { + dbGetQuery(conn, sprintf(digest_sql[[table]], schema), + params = list(wsg))[[1]] +} +working_habitat_digest <- function(wsg) { + dbGetQuery(conn, sprintf( + "SELECT md5(string_agg(t::text, '|' ORDER BY id_segment, species_code)) + FROM %s.streams_habitat t", working_of(wsg)))[[1]] +} +path_base_digest <- file.path(dir_out, "base_habitat_digest.csv") +path_recompute <- file.path(dir_out, "base_recompute.csv") + +# -- base: default over the closure, downstream first ------------------------------------ +run_base <- function() { + closure <- lnk_wsg_resolve(cfg_default, loaded, wsgs = focal, expand = TRUE, + conn = conn) + say("base: %s, %d WSGs (focal %s) into %s", cfg_default$name, + length(closure), paste(focal, collapse = ","), cfg_default$pipeline$schema) + writeLines(closure, file.path(dir_out, "closure.txt")) + sch <- cfg_default$pipeline$schema + for (w in closure) { + active <- lnk_pipeline_species(cfg_default, loaded, w) + if (length(active) == 0L) { + say("base %s: no modelled species, skipped", w) + next + } + # Resume: access is persisted last, so it marks a finished WSG. It is + # reused only when it was built from this commit with a clean tree (its + # run-log row) and, if focal, its working schema and its digest in this + # --out survive; anything else is re-run. + done <- dbExistsTable(conn, Id(schema = sch, table = "streams_access")) && + nrow(dbGetQuery(conn, sprintf( + "SELECT 1 FROM %s.streams_access WHERE watershed_group_code = $1 + LIMIT 1", sch), params = list(w))) > 0L && + isTRUE(dbGetQuery(conn, sprintf( + "SELECT NOT link_dirty AND left(link_sha, %d) = $2 AS ok + FROM %s.log WHERE watershed_group_code = $1 + ORDER BY date_start DESC LIMIT 1", nchar(head_sha), sch), + params = list(w, head_sha))$ok) && + (!w %in% focal || + (dbExistsTable(conn, Id(schema = working_of(w), table = "streams")) && + file.exists(path_base_digest) && + w %in% utils::read.csv(path_base_digest)$watershed_group_code)) + if (done) { + say("base %s: already persisted, skipped", w) + next + } + guard <- lnk_wsg_downstream_check(conn, aoi = w, cfg = cfg_default, + loaded = loaded, on_fail = "error") + t0 <- Sys.time() + lnk_pipeline_run(conn, aoi = w, cfg = cfg_default, loaded = loaded, + schema = working_of(w), mapping_code = FALSE, + cleanup_working = !w %in% focal, notes = guard$note) + if (w %in% focal) { + # Written per WSG, so a resumed run keeps the digests already taken. + dg <- if (file.exists(path_base_digest)) { + utils::read.csv(path_base_digest, colClasses = "character") + } else { + data.frame(watershed_group_code = character(0), digest = character(0)) + } + dg <- rbind(dg[dg$watershed_group_code != w, ], + data.frame(watershed_group_code = w, + digest = working_habitat_digest(w))) + utils::write.csv(dg[order(dg$watershed_group_code), ], path_base_digest, + row.names = FALSE) + } + say("base %s done in %.1f min", w, + as.numeric(difftime(Sys.time(), t0, units = "mins"))) + } + # Re-settle access on the focal WSGs against the whole closure, after every + # base WSG, as the post-consolidate recompute does (wsg_recompute_one.R, + # whose timeouts and log_recompute row this repeats; its mapping_code step + # does not apply, since the base run builds none). + dbExecute(conn, "SET statement_timeout = '600000'") + dbExecute(conn, "SET lock_timeout = '60000'") + rc <- list() + for (w in focal) { + active <- lnk_pipeline_species(cfg_default, loaded, w) + before <- digest_of(sch, "streams_access", w) + rlog <- .lnk_log_recompute_start(conn, cfg = cfg_default, aoi = w, + views_prebuilt = FALSE) + tryCatch({ + lnk_access(conn, cfg_default, aoi = w, + table_streams = paste0(sch, ".streams"), + table_barriers = paste0(sch, ".barriers"), + table_to = paste0(sch, ".streams_access"), + merge = TRUE, + presence = lnk_presence(loaded$wsg_species_presence, w), + species = active) + lnk_wsg_downstream_check(conn, aoi = w, cfg = cfg_default, + loaded = loaded, on_fail = "error") + }, error = function(e) { + .lnk_log_recompute_fail(conn, cfg_default, rlog$recompute_id, + message = conditionMessage(e)) + stop(e) + }) + .lnk_log_recompute_finish(conn, cfg_default, rlog$recompute_id, + species = active) + same <- identical(before, digest_of(sch, "streams_access", w)) + rc[[w]] <- data.frame(watershed_group_code = w, access_unchanged = same) + say("recompute %s: streams_access %s", w, + if (same) "unchanged" else "CHANGED") + } + dbExecute(conn, "RESET statement_timeout") + dbExecute(conn, "RESET lock_timeout") + # Per WSG, so a base re-run over a subset keeps the others' rows. A report + # only: a second recompute of merged access reads "unchanged" by design. + old <- if (file.exists(path_recompute)) utils::read.csv(path_recompute) else NULL + rc <- do.call(rbind, rc) + rc <- rbind(old[!old$watershed_group_code %in% rc$watershed_group_code, ], rc) + utils::write.csv(rc[order(rc$watershed_group_code), ], path_recompute, + row.names = FALSE) +} + +# -- variants: re-classify on the shared network ------------------------------------------- +copy_access <- function(from, to, wsg) { + cols <- dbGetQuery(conn, + "SELECT column_name FROM information_schema.columns + WHERE table_schema = $1 AND table_name = 'streams_access' + ORDER BY ordinal_position", params = list(to))$column_name + cols_from <- dbGetQuery(conn, + "SELECT column_name FROM information_schema.columns + WHERE table_schema = $1 AND table_name = 'streams_access'", + params = list(from))$column_name + if (!setequal(cols, cols_from)) { + stop("streams_access columns differ between ", from, " and ", to, + call. = FALSE) + } + cl <- paste(cols, collapse = ", ") + dbWithTransaction(conn, { + dbExecute(conn, sprintf( + "DELETE FROM %s.streams_access WHERE watershed_group_code = $1", to), + params = list(wsg)) + dbExecute(conn, sprintf( + "INSERT INTO %1$s.streams_access (%3$s) + SELECT %3$s FROM %2$s.streams_access WHERE watershed_group_code = $1", + to, from, cl), params = list(wsg)) + }) +} + +run_variant <- function(v) { + if (!identical(v, base_variant)) { + cfgs[[v]] <<- write_bundle(as.list(variants[variants$variant == v, ])) + } + cfg <- cfgs[[v]] + sch <- cfg$pipeline$schema + sch_base <- schema_of(base_variant) + base_digest <- utils::read.csv(path_base_digest, colClasses = "character") + sp_v <- variants$species_code[variants$variant == v] + # The base re-classifies every species (its digest is the whole table); a + # variant only its own, in the WSGs where that species has a role. + wsgs_v <- if (identical(v, base_variant)) focal else + intersect(focal, roles$watershed_group_code[roles$species_code == sp_v]) + say("variant %s into %s (%s)", v, sch, paste(wsgs_v, collapse = ",")) + # Sized to the whole bundle (link#194), as lnk_pipeline_run does. + lnk_persist_init(conn, cfg, species = cfg$species) + for (w in wsgs_v) { + if (!dbExistsTable(conn, Id(schema = working_of(w), table = "streams"))) { + stop(working_of(w), " is gone: run --step=base first", call. = FALSE) + } + t0 <- Sys.time() + sp <- if (identical(v, base_variant)) NULL else sp_v + lnk_pipeline_classify(conn, aoi = w, cfg = cfg, loaded = loaded, + schema = working_of(w), species = sp) + lnk_pipeline_connect(conn, aoi = w, cfg = cfg, loaded = loaded, + schema = working_of(w), species = sp) + dg <- working_habitat_digest(w) + if (identical(v, base_variant)) { + want <- base_digest$digest[base_digest$watershed_group_code == w] + if (length(want) != 1L) { + stop("no base habitat digest for ", w, " in ", path_base_digest, + ": run --step=base with this --out first", call. = FALSE) + } + if (!identical(dg, want)) { + stop("re-classifying ", w, " with default's thresholds gave habitat ", + "digest ", dg, ", not the base run's ", want, + ": the re-classify path is not a pure threshold change", + call. = FALSE) + } + } + if (!identical(v, base_variant)) { + lnk_pipeline_persist(conn, aoi = w, cfg = cfg, species = sp, + schema = working_of(w)) + # The persisted access is the working copy, for this species only, and + # from before the base's recompute. Access reads no habitat threshold + # (classify and connect never touch it), so the base's recomputed rows, + # every species, replace it. + copy_access(sch_base, sch, w) + } + for (tb in names(digest_sql)) { + if (!identical(digest_of(sch, tb, w), digest_of(sch_base, tb, w))) { + stop(sch, ".", tb, " differs from ", sch_base, " in ", w, + call. = FALSE) + } + } + record_built(v, w) + say("variant %s %s done in %.1f min (habitat %s)", v, w, + as.numeric(difftime(Sys.time(), t0, units = "mins")), substr(dg, 1, 8)) + } +} + +# -- stamp --------------------------------------------------------------------------------- +write_stamp <- function() { + fresh_sha <- .lnk_pkg_git_sha("fresh") + bundle_hash <- vapply(names(cfgs), function(v) { + substr(digest::digest(file = cfgs[[v]]$files$parameters_habitat_thresholds$path, + algo = "sha256"), 1, 12) + }, character(1)) + run_uid <- dbGetQuery(conn, sprintf( + "SELECT string_agg(DISTINCT run_uid, ', ') FROM %s.log + WHERE watershed_group_code = ANY($1)", schema_of(base_variant)), + params = list(paste0("{", paste(focal, collapse = ","), "}")))[[1]] + # Appended, one block per invocation: a resumed or partial run must not + # erase the record of the one before it. + cat(c( + "---", + sprintf("date: %s", format(Sys.time(), "%Y-%m-%d %H:%M %Z")), + sprintf("step: %s; focal: %s; variants: %s", step, + paste(focal, collapse = ","), paste(run_variants, collapse = ",")), + sprintf("link: %s @ %s%s (at launch)", utils::packageVersion("link"), + head_sha, + if (length(dirty) > 0L) " (dirty, --allow-dirty)" else ""), + sprintf("variants: %s (md5 %s); roles: %s (md5 %s)", path_variants, + unname(tools::md5sum(path_variants)), path_roles, + unname(tools::md5sum(path_roles))), + sprintf("fresh: %s @ %s", utils::packageVersion("fresh"), + if (is.na(fresh_sha)) "no recorded sha" else fresh_sha), + "db: docker fwapg localhost:5432", + sprintf("base run_uid(s) in %s.log: %s", schema_of(base_variant), + if (is.na(run_uid)) "none" else run_uid), + sprintf("bcfishobs.observations rows: %s", + dbGetQuery(conn, "SELECT count(*) FROM bcfishobs.observations")[[1]]), + sprintf("thresholds sha256 (12): %s", + paste(names(bundle_hash), bundle_hash, sep = "=", collapse = ", ")), + ""), file = file.path(dir_out, "stamp_build.txt"), sep = "\n", + append = TRUE) +} + +t_all <- Sys.time() +if (step %in% c("all", "base")) run_base() +if (step %in% c("all", "variants")) { + # The base variant first: its digest check is what licenses the others. + for (v in run_variants) { + run_variant(v) + } +} +write_stamp() +say("build %s done in %.1f min", step, + as.numeric(difftime(Sys.time(), t_all, units = "mins"))) +dbDisconnect(conn) diff --git a/data-raw/habitat_variants_score.R b/data-raw/habitat_variants_score.R new file mode 100644 index 00000000..b29589da --- /dev/null +++ b/data-raw/habitat_variants_score.R @@ -0,0 +1,546 @@ +#!/usr/bin/env Rscript +# habitat_variants_score.R — score the threshold variants built by +# habitat_variants_build.R against fish observations, and apply the #284 +# step 5 rule (research/habitat_thresholds.md, "Scoring design"). +# +# Per variant schema: lnk_habitat_validate() capture and cost, at each buffer. +# Per ladder step (a variant and its --variants `step_from`): +# lnk_habitat_validate_band(), the observations per km on the segments the +# step moves against the core every step of that ladder agrees on. +# +# The rule, applied mechanically to the held-out WSGs of the step's species, +# pooled (in-sample rows are written beside it and never decide): +# - a band is habitat when n_band >= 10 and density_ratio >= 0.5; +# - a loosening step is taken when its band is habitat, a tightening step +# when its band is not; n_band < 10 keeps the value; +# - walking out from `default`, the first step not taken stops the ladder; +# an underpowered step decides nothing, so a walk that reaches one has no +# value and the step 1-4 verdict in the bundle stands. +# The literature veto is applied by hand in the research doc, not here. +# +# Rscript data-raw/habitat_variants_score.R \ +# [--variants=data-raw/habitat_score/variants.csv] \ +# [--roles=data-raw/habitat_score/wsg_roles.csv] \ +# [--wsgs=...] [--buffers=0,100] [--prefix=score284_] \ +# [--out=data-raw/logs/habitat_score_284] +# +# Absences come from LNK_KNOWLEDGE_DIR (the private `knowledge` repo) through +# data-raw/habitat_validate_inputs.R, as habitat_validate.R reads them; only +# counts are written. Read-only against docker fwapg: session temp tables. +# +# Writes to --out: +# summary.csv lnk_habitat_validate()$summary, every variant x buffer +# totals.csv summed per variant x species x role x stage x buffer +# bands.csv per step x WSG x direction x stage (observations and +# absence sites) +# bands_pooled.csv the same summed per step x role x direction x stage +# verdict.csv the rule per step, and the walked-out value per ladder +# bridge_band.csv rearing km each added band holds with and without +# spawning upstream +# stamp_score.txt environment stamp + +suppressPackageStartupMessages({ + pkgload::load_all(quiet = TRUE) + library(DBI) +}) + +opt <- function(name, default = NULL) { + a <- grep(paste0("^--", name, "="), commandArgs(trailingOnly = TRUE), + value = TRUE) + if (length(a) == 0L) return(default) + sub(paste0("^--", name, "="), "", a[length(a)]) +} +split_csv <- function(x) { + if (is.null(x)) return(character(0)) + v <- trimws(strsplit(x, ",")[[1]]) + v[nzchar(v)] +} +say <- function(...) message(format(Sys.time(), "%H:%M:%S "), sprintf(...)) + +path_variants <- opt("variants", file.path("data-raw", "habitat_score", + "variants.csv")) +path_roles <- opt("roles", file.path("data-raw", "habitat_score", + "wsg_roles.csv")) +prefix <- opt("prefix", "score284_") +dir_out <- opt("out", file.path("data-raw", "logs", "habitat_score_284")) +buffers <- as.numeric(split_csv(opt("buffers", "0,100"))) +if (anyNA(buffers) || !0 %in% buffers) { + stop("--buffers must be numbers and include 0 (bands are buffer 0)", + call. = FALSE) +} +n_min <- 10L +ratio_min <- 0.5 + +variants <- utils::read.csv(path_variants, colClasses = "character", + na.strings = "") +roles <- utils::read.csv(path_roles, colClasses = "character") +base_variant <- variants$variant[is.na(variants$column)] +stopifnot(length(base_variant) == 1L) +# The ladders must be well formed before anything runs: every step_from names +# a listed variant, and each variant is stepped from by at most one other, so +# every ladder is one chain out from the base (no cycle, no branch below it). +local({ + steps_from <- variants$step_from[!is.na(variants$column)] + if (!all(steps_from %in% variants$variant)) { + stop("step_from names no listed variant: ", + paste(setdiff(steps_from, variants$variant), collapse = ", "), + call. = FALSE) + } + below <- steps_from[steps_from != base_variant] + if (anyDuplicated(below)) { + stop("a ladder branches below the base at: ", + paste(unique(below[duplicated(below)]), collapse = ", "), + call. = FALSE) + } + for (v in variants$variant) { + seen <- character(0) + while (!identical(v, base_variant)) { + if (v %in% seen) stop("step_from cycle through ", v, call. = FALSE) + seen <- c(seen, v) + v <- variants$step_from[variants$variant == v] + } + } +}) + +focal <- toupper(split_csv(opt("wsgs"))) +if (length(focal) == 0L) focal <- unique(roles$watershed_group_code) +roles <- roles[roles$watershed_group_code %in% focal, ] +species <- sort(unique(roles$species_code)) +schema_of <- function(v) paste0(prefix, v) +outputs <- c("summary.csv", "totals.csv", "bands.csv", "bands_pooled.csv", + "verdict.csv", "bridge_band.csv", "stamp_score.txt") +unlink(file.path(dir_out, outputs)) + +# Taken at launch: the code that runs is the code at the start. +head_sha <- system("git rev-parse --short HEAD", intern = TRUE) +dirty <- length(system(paste( + "git status --porcelain -- R inst/extdata data-raw/habitat_score", + "data-raw/habitat_variants_score.R data-raw/habitat_validate_inputs.R", + "data-raw/fiss_absence_taxa.csv"), intern = TRUE)) > 0L + +conn <- lnk_db_conn(dbname = "fwapg", host = "localhost", port = 5432L, + user = "postgres", password = "postgres") + +# -- bundles: default, and the thin variant bundles the build wrote -------------- +cfg_of <- function(v) { + if (identical(v, base_variant)) return(lnk_config("default")) + d <- file.path(dir_out, "bundles", v) + if (!dir.exists(d)) { + stop("no bundle for ", v, " under ", dir_out, + ": run habitat_variants_build.R first", call. = FALSE) + } + lnk_config(normalizePath(d)) +} +cfgs <- stats::setNames(lapply(variants$variant, cfg_of), variants$variant) +# The values below label every band, so they must be the ones each schema was +# built from. built.csv (written by the build once a schema's checks pass) +# names the bundle sha each schema came from; the bundle on disk must still be +# that one, differ from the current default in exactly its own cell, and +# carry the value --variants gives it. +path_built <- file.path(dir_out, "built.csv") +if (!file.exists(path_built)) { + stop("no ", path_built, ": run habitat_variants_build.R first", call. = FALSE) +} +built <- utils::read.csv(path_built, colClasses = "character") +thr_now <- utils::read.csv( + cfgs[[base_variant]]$files$parameters_habitat_thresholds$path, + colClasses = "character") +for (v in variants$variant) { + path_thr <- cfgs[[v]]$files$parameters_habitat_thresholds$path + sp_v <- if (identical(v, base_variant)) species else + variants$species_code[variants$variant == v] + w_v <- intersect(focal, roles$watershed_group_code[roles$species_code %in% sp_v]) + b <- built[built$variant == v & built$watershed_group_code %in% w_v, ] + if (!setequal(b$watershed_group_code, w_v) || nrow(b) != length(w_v)) { + stop(v, " was not built for: ", + paste(setdiff(w_v, b$watershed_group_code), collapse = ", "), + " (", path_built, ")", call. = FALSE) + } + if (!all(b$schema == schema_of(v))) { + stop(path_built, " records ", v, " in another schema than ", schema_of(v), + call. = FALSE) + } + if (!all(b$thresholds_sha256 == + digest::digest(file = path_thr, algo = "sha256"))) { + stop("the thresholds bundle for ", v, " is not the one every scored WSG ", + "of ", schema_of(v), " was built from", call. = FALSE) + } + if (identical(v, base_variant)) next + r <- variants[variants$variant == v, ] + thr <- utils::read.csv(path_thr, colClasses = "character") + n_diff <- sum(mapply(function(a, b) { + sum(!((a == b) %in% TRUE) & !(is.na(a) & is.na(b))) + }, thr, thr_now)) + got <- as.numeric(thr[[r$column]][thr$species_code == r$species_code]) + if (n_diff != 1L || !isTRUE(all.equal(got, as.numeric(r$value)))) { + stop("bundle ", v, " is not default with ", r$column, " = ", r$value, + " for ", r$species_code, " (", n_diff, " cells differ; it holds ", + got, ")", call. = FALSE) + } +} +loaded <- suppressWarnings(lnk_load_overrides(cfgs[[base_variant]])) + +# Access was copied from the base at build time; a later base pass can move +# the base's. Each variant must still carry the base's access, per WSG. +digest_access <- function(sch, w) { + dbGetQuery(conn, sprintf( + "SELECT md5(string_agg(t::text, '|' ORDER BY t.id_segment)) + FROM (SELECT * FROM %s.streams_access + WHERE watershed_group_code = $1) t", sch), + params = list(w))[[1]] +} +for (v in setdiff(variants$variant, base_variant)) { + for (w in intersect(focal, roles$watershed_group_code[ + roles$species_code == variants$species_code[variants$variant == v]])) { + if (!identical(digest_access(schema_of(v), w), + digest_access(schema_of(base_variant), w))) { + stop(schema_of(v), ".streams_access differs from ", + schema_of(base_variant), " in ", w, ": rebuild the variants", + call. = FALSE) + } + } +} + +# -- absences and pooling: the same code path as habitat_validate.R ------------------ +source(file.path("data-raw", "habitat_validate_inputs.R")) +absences <- hv_fiss_absences(conn, species) +abs_note <- attr(absences, "reason") +if (!is.null(abs_note)) absences <- NULL +pool <- hv_pooling(data.frame(config = "default", stringsAsFactors = FALSE), + list(focal), species, pooling_cfg = "default") + +# -- validate every variant schema ------------------------------------------------------- +# A variant schema holds habitat only for its own species (the build +# re-classifies just that one), so it is validated for that species only; +# another species' empty table would read as zero capture at zero cost. +species_of <- function(v) { + if (identical(v, base_variant)) species else + intersect(species, variants$species_code[variants$variant == v]) +} +aoi_of <- function(sp) { + intersect(focal, roles$watershed_group_code[roles$species_code %in% sp]) +} +runs <- list() +for (v in variants$variant) { + for (b in buffers) { + say("validating %s (%s), buffer %s m", v, schema_of(v), b) + r <- do.call(lnk_habitat_validate, c(list( + conn, aoi = aoi_of(species_of(v)), cfg = cfgs[[v]], loaded = loaded, + species = species_of(v), schema = schema_of(v), buffer_m = b, + absences = absences), pool$args)) + r$summary <- cbind(data.frame(variant = v), r$summary) + runs[[paste(v, b)]] <- r + } +} +summary <- do.call(rbind, lapply(runs, `[[`, "summary")) +rownames(summary) <- NULL +utils::write.csv(summary, file.path(dir_out, "summary.csv"), + row.names = FALSE, na = "") + +# Every variant must retain the same observations on the same segments, or a +# capture difference mixes an attachment difference into a threshold one. +obs_key <- function(o) { + sort(paste(o$species_code, o$watershed_group_code, o$observation_key, + o$id_segment)) +} +obs_base <- runs[[paste(base_variant, 0)]]$observations +for (v in setdiff(variants$variant, base_variant)) { + o_v <- runs[[paste(v, 0)]]$observations + o_b <- obs_base[obs_base$species_code %in% species_of(v) & + obs_base$watershed_group_code %in% aoi_of(species_of(v)), ] + if (!identical(obs_key(o_v), obs_key(o_b))) { + stop(v, " retained or attached different observations than ", + base_variant, call. = FALSE) + } +} + +summary$role <- roles$role[match( + paste(summary$watershed_group_code, summary$species_code), + paste(roles$watershed_group_code, roles$species_code))] +summary <- summary[!is.na(summary$role), ] +cols_n <- c("n_obs", "n_accessible", "n_spawning", "n_rearing", + "n_rearing_any", "n_obs_outside_uhc_spawn", + "n_spawning_outside_uhc", "n_obs_outside_uhc_rear", + "n_rearing_any_outside_uhc", "accessible_km", "spawning_km", + "rearing_km") +key_t <- c("variant", "buffer_m", "species_code", "role", "stage") +totals <- stats::aggregate(summary[cols_n], summary[key_t], sum) +for (k in c("accessible", "spawning", "rearing", "rearing_any")) { + totals[[paste0("share_", k)]] <- ifelse( + totals$n_obs > 0, totals[[paste0("n_", k)]] / totals$n_obs, NA_real_) +} +totals <- totals[do.call(order, totals[rev(key_t)]), ] +utils::write.csv(totals, file.path(dir_out, "totals.csv"), row.names = FALSE, + na = "") + +# -- absence sites attached to segments --------------------------------------------------- +# The validator's absence output is counts; to count absence sites in a band +# they are attached the way observations are, by running them through the +# validator as an observation source (model species codes, no pooling). +abs_obs <- NULL +if (!is.null(absences) && nrow(absences) > 0L) { + a <- absences[absences$watershed_group_code %in% focal, , drop = FALSE] + if (nrow(a) > 0L) { + loaded_abs <- loaded + loaded_abs$observation_exclusions <- NULL + abs_obs <- lnk_habitat_validate( + conn, aoi = focal, cfg = cfgs[[base_variant]], loaded = loaded_abs, + species = species, schema = schema_of(base_variant), observations = a, + species_obs = list(), match_types = NULL, + source_exclude = NULL)$observations + } +} + +# -- bands, per ladder step ------------------------------------------------------------------ +num <- function(x) as.numeric(x) +thr_default <- utils::read.csv( + cfgs[[base_variant]]$files$parameters_habitat_thresholds$path) +value_of <- function(v, sp, column) { + r <- variants[variants$variant == v, ] + if (identical(v, base_variant) || !identical(r$column, column)) { + return(thr_default[[column]][thr_default$species_code == sp]) + } + num(r$value) +} +steps <- variants[!is.na(variants$column), ] +steps$value_from <- mapply(value_of, steps$step_from, steps$species_code, + steps$column) +steps$direction <- ifelse(num(steps$value) > steps$value_from, "added", + "removed") +ladder_of <- function(sp, column) { + c(base_variant, variants$variant[variants$species_code %in% sp & + variants$column %in% column]) +} +# A user_habitat_classification reach is forced to habitat under every +# variant, so it would sit in the core and pull its density toward wherever +# the confirmed reaches are. The band function does not exclude them; stop +# rather than score a biased core. +uhc <- loaded$user_habitat_classification +if (!is.null(uhc)) { + for (k in seq_len(nrow(steps))) { + hit <- uhc$species_code == steps$species_code[k] & + uhc[[steps$flag[k]]] %in% 1 + if (any(hit)) { + stop(sum(hit), " user_habitat_classification ", steps$flag[k], + " reaches for ", steps$species_code[k], " would sit in the core ", + "of step ", steps$variant[k], call. = FALSE) + } + } +} +stages <- c("any", "spawn", "rear") +bands <- list() +for (k in seq_len(nrow(steps))) { + s <- steps[k, ] + w_sp <- roles$watershed_group_code[roles$species_code == s$species_code] + core <- schema_of(ladder_of(s$species_code, s$column)) + for (st in stages) { + b <- lnk_habitat_validate_band( + conn, aoi = w_sp, species = s$species_code, flag = s$flag, + schema = schema_of(s$variant), schema_ref = schema_of(s$step_from), + observations = obs_base, stage = st, schema_core = core) + b$n_absence_band <- NA_integer_ + if (!is.null(abs_obs) && identical(st, "any")) { + ab <- lnk_habitat_validate_band( + conn, aoi = w_sp, species = s$species_code, flag = s$flag, + schema = schema_of(s$variant), schema_ref = schema_of(s$step_from), + observations = abs_obs, stage = "any", schema_core = core) + # Surveyed WSGs, not those with an absence row: a surveyed WSG with no + # absence site in the band reports 0, not "not assessed". + covered <- attr(absences, "covered") + b$n_absence_band <- ifelse(b$watershed_group_code %in% covered, + ab$n_band, NA_integer_) + } + bands[[length(bands) + 1L]] <- cbind( + data.frame(variant = s$variant, step_from = s$step_from, + column = s$column, value_from = s$value_from, + value = num(s$value), step_direction = s$direction, + obs_stage = s$obs_stage), + b) + } +} +bands <- do.call(rbind, bands) +bands$role <- roles$role[match( + paste(bands$watershed_group_code, bands$species_code), + paste(roles$watershed_group_code, roles$species_code))] +utils::write.csv(bands, file.path(dir_out, "bands.csv"), row.names = FALSE, + na = "") +# A ladder step moves habitat one way. Anything moved the other way means the +# ladder is not nested and the core is not "default outside every band". +against <- bands[bands$direction != bands$step_direction & bands$band_km > 0, ] +if (nrow(against) > 0L) { + stop("steps moved habitat against their direction (see bands.csv): ", + paste(unique(paste(against$variant, against$watershed_group_code)), + collapse = ", "), call. = FALSE) +} + +key_b <- c("variant", "step_from", "column", "value_from", "value", + "step_direction", "obs_stage", "species_code", "flag", "role", + "direction", "stage") +pooled <- stats::aggregate(bands[c("band_km", "n_band", "core_km", "n_core")], + bands[key_b], sum) +pooled <- cbind(pooled, .lnk_hvb_density(pooled$n_band, pooled$band_km, + pooled$n_core, pooled$core_km)) +pooled <- pooled[do.call(order, pooled[c("species_code", "column", "value", + "role", "direction", "stage")]), ] +utils::write.csv(pooled, file.path(dir_out, "bands_pooled.csv"), + row.names = FALSE, na = "") + +# -- the rule ---------------------------------------------------------------------------------- +rule <- pooled[pooled$role == "held_out" & + pooled$direction == pooled$step_direction & + pooled$stage == pooled$obs_stage, ] +if (nrow(rule) == 0L) { + message("no held-out WSG in scope: verdict.csv carries no rows") +} +rule$band_is_habitat <- rule$n_band >= n_min & + !is.na(rule$density_ratio) & rule$density_ratio >= ratio_min +rule$decision <- ifelse( + rule$n_band < n_min, "keep (n < 10)", + ifelse((rule$step_direction == "added") == rule$band_is_habitat, + "take", "refuse")) +# Walk each ladder out from default once, to its last step, and write that +# one outcome on every row of the ladder. A ladder is the chain from default +# to a tip (a variant no other variant steps from); a ladder that branches at +# default (one step looser, one tighter) is two ladders. The walk stops at the +# first step not decided "take". A "refuse" ends it at the value before that +# step. An underpowered step decides nothing: the ladder has no value +# (walked_value NA) and the step 1-4 verdict in the bundle stands. +chain_to <- function(v) { + chain <- character(0) + # Bounded, though the ladder check at the top already rules out a cycle. + while (!identical(v, base_variant) && length(chain) <= nrow(variants)) { + chain <- c(v, chain) + v <- variants$step_from[variants$variant == v] + } + chain +} +tips <- setdiff(rule$variant, variants$step_from) +rule$ladder_tip <- rep(NA_character_, nrow(rule)) +rule$walk_status <- rep(NA_character_, nrow(rule)) +rule$walked_value <- rep(NA_real_, nrow(rule)) +for (tip in tips) { + chain <- chain_to(tip) + dec <- rule$decision[match(chain, rule$variant)] + stop_at <- which(dec != "take" | is.na(dec))[1] + r <- rule[rule$variant == tip, ] + if (is.na(stop_at)) { + status <- paste("taken through", tip) + value <- num(variants$value[variants$variant == tip]) + } else if (identical(dec[stop_at], "refuse")) { + status <- paste("refused at", chain[stop_at]) + value <- if (stop_at == 1L) { + value_of(base_variant, r$species_code, r$column) + } else { + num(variants$value[variants$variant == chain[stop_at - 1L]]) + } + } else { + status <- paste("underpowered at", chain[stop_at], + "- the step 1-4 verdict stands") + value <- NA_real_ + } + on <- rule$variant %in% chain + rule$ladder_tip[on] <- tip + rule$walk_status[on] <- status + rule$walked_value[on] <- value +} +utils::write.csv(rule, file.path(dir_out, "verdict.csv"), row.names = FALSE, + na = "") + +# -- question 2: added rearing with and without spawning upstream ------------------------- +# .frs_cluster_both() keeps a rearing cluster with spawning anywhere upstream, +# and otherwise only through the downstream bridge; this splits each added +# rearing band the same way, per segment, against the variant's own spawning. +bridge <- list() +for (k in which(steps$flag == "rearing" & steps$direction == "added")) { + s <- steps[k, ] + spl <- tolower(s$species_code) + w_sp <- roles$watershed_group_code[roles$species_code == s$species_code] + sv <- schema_of(s$variant) + sr <- schema_of(s$step_from) + d <- dbGetQuery(conn, sprintf( + "WITH band AS ( + SELECT s.* FROM %1$s.streams s + JOIN %1$s.streams_habitat_%3$s h + ON h.id_segment = s.id_segment + AND h.watershed_group_code = s.watershed_group_code + LEFT JOIN %2$s.streams_habitat_%3$s r + ON r.id_segment = s.id_segment + AND r.watershed_group_code = s.watershed_group_code + WHERE s.watershed_group_code = ANY($1) + AND h.rearing AND NOT coalesce(r.rearing, false)), + spawn AS ( + SELECT s.* FROM %1$s.streams s + JOIN %1$s.streams_habitat_%3$s h + ON h.id_segment = s.id_segment + AND h.watershed_group_code = s.watershed_group_code + WHERE s.watershed_group_code = ANY($1) AND h.spawning) + SELECT b.watershed_group_code, + EXISTS ( + SELECT 1 FROM spawn p + WHERE p.watershed_group_code = b.watershed_group_code + AND whse_basemapping.fwa_upstream( + b.blue_line_key, b.downstream_route_measure, + b.wscode_ltree, b.localcode_ltree, + p.blue_line_key, p.downstream_route_measure, + p.wscode_ltree, p.localcode_ltree)) AS spawning_upstream, + -- in the gradient window the step opens, or admitted through + -- connectivity (a cluster the step newly connects) + (b.gradient > $2 AND b.gradient <= $3) AS in_window, + sum(b.length_metre) / 1000 AS km + FROM band b + GROUP BY 1, 2, 3", sv, sr, spl), + params = list(paste0("{", paste(w_sp, collapse = ","), "}"), + s$value_from, num(s$value))) + if (nrow(d) > 0L) { + bridge[[length(bridge) + 1L]] <- cbind( + data.frame(variant = s$variant, step_from = s$step_from, + species_code = s$species_code), d) + } +} +if (length(bridge) > 0L) { + bridge <- do.call(rbind, bridge) + bridge$role <- roles$role[match( + paste(bridge$watershed_group_code, bridge$species_code), + paste(roles$watershed_group_code, roles$species_code))] + utils::write.csv(bridge, file.path(dir_out, "bridge_band.csv"), + row.names = FALSE, na = "") +} + +# -- stamp ------------------------------------------------------------------------------------- +fresh_sha <- .lnk_pkg_git_sha("fresh") +writeLines(c( + sprintf("date: %s", format(Sys.time(), "%Y-%m-%d %H:%M %Z")), + sprintf("link: %s @ %s%s (at launch)", utils::packageVersion("link"), + head_sha, if (dirty) " (dirty)" else ""), + sprintf("fresh: %s @ %s", utils::packageVersion("fresh"), + if (is.na(fresh_sha)) "no recorded sha" else fresh_sha), + "db: docker fwapg localhost:5432", + sprintf("variants: %s (md5 %s): %s", path_variants, + unname(tools::md5sum(path_variants)), + paste(variants$variant, collapse = ",")), + sprintf("roles: %s (md5 %s)", path_roles, unname(tools::md5sum(path_roles))), + # The build this score verified (built.csv rows for the scored WSGs). + vapply(variants$variant, function(v) { + b <- built[built$variant == v & built$watershed_group_code %in% focal, ] + sprintf("built %s: thresholds sha256 %s; link %s%s; %d WSGs, %s to %s", v, + substr(b$thresholds_sha256[1], 1, 12), + paste(unique(b$link_head), collapse = ","), + if (any(b$dirty %in% "TRUE")) " (dirty)" else "", nrow(b), + min(b$built_at), max(b$built_at)) + }, character(1)), + sprintf("focal: %s; species: %s; buffers: %s m", + paste(focal, collapse = ","), paste(species, collapse = ","), + paste(buffers, collapse = ",")), + sprintf("rule: n_band >= %d and density_ratio >= %s on held-out WSGs", + n_min, ratio_min), + sprintf("pooling: %s", pool$note), + sprintf("bcfishobs.observations rows: %s", + dbGetQuery(conn, "SELECT count(*) FROM bcfishobs.observations")[[1]]), + if (!is.null(abs_note)) sprintf("absences: none (%s)", abs_note) else + if (is.null(absences)) "absences: none (LNK_KNOWLEDGE_DIR unset)" else + sprintf("absences: FISS snapshots %s; knowledge @ %s", + paste(attr(absences, "covered"), collapse = ","), + attr(absences, "knowledge_sha"))), + file.path(dir_out, "stamp_score.txt")) +dbDisconnect(conn) +say("wrote %s", dir_out) diff --git a/planning/active/progress.md b/planning/active/progress.md index 607999fd..47a6e2ca 100644 --- a/planning/active/progress.md +++ b/planning/active/progress.md @@ -6,3 +6,9 @@ - Created branch `284-research-calibrate-ch-and-bt-gradient-an` off main (097419f). - Scaffolded PWF baseline with approved phases. User: "go all phases" — run to PR. - Next: Phase 1. +- Phase 1: absence taxa to `data-raw/fiss_absence_taxa.csv`; loaders to `habitat_validate_inputs.R`; #283 outputs byte-identical (knowledge pinned at 508bf44). +- Phase 2: `lnk_habitat_validate_band()` + 36 tests; mutation-tested in a scratch copy. +- Plan review (Plan agent): 3 blockers. Power check confirmed B1; operator chose BT only with a widened held-out set, and an underpowered step changes nothing. Rule revised with its counts before commit. +- Phase 3 code written (`habitat_variants_build.R`, `habitat_variants_score.R`), review gaps G1–G8, AC1, AC4 folded in. +- Code-check: 5 rounds plus an enumeration. Rounds 3, 4 and 5 each found a defect inside the previous fix (the per-row walk, bundle provenance, the resume key). All fixed and probed. Summary in `review-enumeration.md`. +- BULL pre-flight: invariants hold, bands reconcile, and the pipeline runs end to end. Next: commit, drop the pre-flight scratch schemas, launch the full build detached. diff --git a/planning/active/review-enumeration.md b/planning/active/review-enumeration.md new file mode 100644 index 00000000..1282aa8a --- /dev/null +++ b/planning/active/review-enumeration.md @@ -0,0 +1,20 @@ +# Code-check termination: enumeration after round 5 (2026-09-29) + +Rounds 3, 4 and 5 each found a defect inside the previous round's fix. The shared mechanism, named in round 3, is a partial producer read by a whole-population reader. So the loop ends on this enumeration, not on a quiet round. + +The table takes every artifact the build writes against every reader, as listed in `review-round5.md`. Each FAIL from round 5 is re-checked against the fixed code with a probe. + +| artifact → reader | round 5 | now | evidence | +|---|---|---|---| +| base schema → build resume | FAIL: reused the pre-flight's dirty rows, and the digest came from another `--out` | HOLDS | Resume requires a clean log row at this HEAD, and for focal WSGs the working schema plus a digest row in this `--out`. Probe: the three dirty pre-flight rows give `ok = f`, and a missing row gives FALSE, so the WSG re-runs. | +| base schema → digest licence | FAIL: an empty lookup was reported as a re-classify defect | HOLDS | `length(want) != 1` now stops with "run --step=base with this --out first". | +| base schema → stamp run_uid | FAIL: NULL | accepted | The launch exports `LNK_RUN_UID`. | +| variant schema → score (threshold per WSG) | FAIL: built.csv was per variant | HOLDS | built.csv is keyed on variant × WSG. The score requires every scored WSG, one sha, and the right schema. Probe: after a BULL-only build, a 12-WSG score stops with "default was not built for: ELKR, …". | +| bundles → score | FAIL per WSG | HOLDS | Bundles are written in `run_variant()`. The per-WSG sha is checked against the bundle, and the bundle against the current default (one cell). | +| built.csv → score | FAIL | HOLDS | As above. | +| stamps and score outputs → reader | FAIL: the build the score verified was not recorded | HOLDS | `stamp_score.txt` carries a `built :` line per variant (sha, link, dirty, WSG count, time range). | +| habitat_validate.R stamp → reader | low: dirty taken at the end | HOLDS | Dirty and HEAD are now both taken at launch. | +| working schemas, closure.txt, base_recompute.csv | HOLDS / no reader | HOLDS | The 23-WSG post-condition is read from the DB (Phase 4), not from closure.txt. | +| ladder shape → both scripts | round 4 FAIL, fixed | HOLDS | Probe: a trimmed ladder stops with "step_from names no listed variant", where it used to hang. | + +Seven review agents were spent on this task: 1 plan review and 5 code-check rounds, plus this enumeration done in-session. That is past the ~5 bound. The extra rounds found a variants step that could never pass, a walk that named the wrong value, and a resume that would have stopped the full run after 75 minutes. diff --git a/planning/active/review-round1.md b/planning/active/review-round1.md new file mode 100644 index 00000000..b8a221d3 --- /dev/null +++ b/planning/active/review-round1.md @@ -0,0 +1,34 @@ +# Code review, round 1: staged diff for #284 step 5 + +## Findings + +- **[severity: bug]** data-raw/habitat_variants_build.R:389-402. On any multi-species WSG, the pre-copy `same_access` check stops the variants step with a false failure. + - **Cause.** `lnk_pipeline_persist(..., species = sp)` projects only the variant species' per-species access columns into `.streams_access`. It writes `has_barriers_bt_dnstr` and `access_bt` (`R/lnk_pipeline_persist.R:159-161`, `.lnk_cols_streams_access_per_sp(species)`). Every other species' `access_` and `has_barriers__dnstr` is left NULL. + - **Why the digests differ.** `digest_sql$streams_access` hashes `SELECT *` row text. The base schema has those columns populated: `score284_default.streams_access` for LARL has `access_rb` and `access_wct` non-NULL on all 91,083 rows. So the variant digest never equals the base digest in a WSG with more than one active species. + - **Scope.** Under `default`, all 12 focal WSGs have more than one active species (for example BULL is BT, WCT, RB and GR; LILL is BT, CH, CM, CO, SK, ST and RB). In the normal downstream-first case the recompute changes nothing, so `access_unchanged` is TRUE and the run hits `stop(... "although the recompute changed nothing")` on the first variant WSG. No variant schema can be built as written. + - **Separate problem: the check cannot test what its comment says.** The comment says it tests that access carries no threshold dependence. But `lnk_pipeline_classify()` and `lnk_pipeline_connect()` never rebuild the working `streams_access`. The comparison is therefore the base run's own pre-recompute access against its persisted copy, and it cannot detect threshold dependence under any outcome. + - **Fix.** Compare only the id, WSG and variant-species columns, or drop this check. The post-copy digest loop at lines 405-410 already makes access identical to the base by construction. + +- **[severity: fragile]** data-raw/habitat_variants_build.R:295-325 and 359/398. `base_recompute.csv` reflects only the most recent `--step=base` invocation, which breaks the check above in both directions. + - **Re-running base.** A re-run (resume, or adding a WSG) re-merges access that has already been merged. That records `access_unchanged = TRUE` even where the first recompute changed it. The working schema still holds the pre-first-recompute access, so the variant check stops falsely. + - **Re-running a subset.** `--step=base --wsgs=X` rewrites the CSV with X only. Every other focal WSG then gets `isTRUE(logical(0))`, which is FALSE, and the check is skipped silently: it fails toward pass. + - **Fix.** If the check is kept, key it to a digest of the working access taken at base-run time, written per WSG the way `base_habitat_digest.csv` already is. + +- **[severity: fragile]** data-raw/habitat_variants_score.R:112-121 with data-raw/habitat_variants_build.R:363-364 and 389. A variant schema holds habitat only for its own species, but every variant is validated over all focal WSGs × every roles species. + - **The trigger.** A roles row is added for a second species in a shared WSG. CH is the stated follow-on, and BABL, BABR, LILL, BULK and MORR all have CH present. + - **Why nothing stops it.** `.lnk_hv_check_schema` passes: streams and streams_access are present, and `lnk_persist_init` created an empty `streams_habitat_ch`. + - **The result.** CH rows for the BT variants in `summary.csv` and `totals.csv` report zero spawning and rearing capture and zero km, as real numbers. Latent with today's BT-only `wsg_roles.csv`, but the README says the scripts name no species and the CSVs carry everything species-specific. Validate each variant only for `sp_v` in its own WSGs, or stop when roles carry more species than a variant persisted. + +- **[severity: fragile]** data-raw/habitat_variants_score.R:232-234. The absence band marks the wrong WSGs as not assessed. + - `covered <- unique(absences$watershed_group_code)` is the set of WSGs holding at least one absence row, not the surveyed set. So a surveyed WSG with zero BT absence sites reports `n_absence_band = NA` ("not assessed") instead of 0. + - `hv_fiss_absences()` already returns the surveyed set as `attr(absences, "covered")`, and that is the set to use. + - This only affects the `bands.csv` reporting column, not the rule. + +Checked and clean: +- `lnk_habitat_validate_band` joins on the full key everywhere; aggregating observations per segment before the join avoids fan-out; NOT/AND precedence is correct; row alignment between the observation and absence band calls is correct; the density-NA semantics hold. +- The rule and walk logic (take and refuse per direction, first step not taken stops the ladder, n < 10 keeps the value) match the research doc. +- The `fwa_upstream` argument order in `bridge_band` is correct (spawning upstream of the band), and `GROUP BY` over the correlated `EXISTS` is valid in Postgres (probed). +- The held-out WSGs are absent from `fresh_default` (the calibration 55). +- `species_code` in the validator's observations is the model species after pooling. +- Classify gates only on the working schema's `streams_breaks`, so variant schemas lacking the closure's barriers do not change the habitat. +- The extends and provenance resolution for the generated bundles looks right. diff --git a/planning/active/review-round2.md b/planning/active/review-round2.md new file mode 100644 index 00000000..f801fc33 --- /dev/null +++ b/planning/active/review-round2.md @@ -0,0 +1,62 @@ +# Code review, round 2: staged diff for #284 step 5 + +## Findings + +- **[severity: bug]** data-raw/habitat_variants_score.R:13-16, 292-315 against research/habitat_thresholds.md "Scoring design" (Rule). `verdict.csv`'s `walked_value` reports a different value from the rule the research doc fixed before the run. **Not inside a round-1 fix.** + - **What the code does.** An underpowered step gets `decision = "keep (n < 10)"`. The walk treats `keep` exactly like `refuse`: it is not `"take"`, so the walk stops there, and `walked_value` falls back to `default`'s value. + - **What the doc says.** "An underpowered step (n < 10) changes nothing. The step 1–4 verdict stands: `default_tuned` keeps 0.1349". The task plan says the same: "`default_tuned`'s 0.1349 stands." + - **Evidence from the pre-flight.** In `preflight/verdict.csv`, both steps read `keep (n < 10)` and both rows carry `walked_value = 0.1049`. The doc's rule on the same numbers gives 0.1349. `walked_value` is the column a reader acts on in Phase 6 ("If the rule moves a value, edit `default_tuned`…"), so read literally it moves BT back to 0.1049. + - **The mixed case.** The two also disagree when the steps are mixed: take 0.1249, then an underpowered step to 0.1349. The walk reports 0.1249 and the doc keeps 0.1349. Nothing in the walk can express "no verdict, the incumbent stands", because the walk is anchored on `default` (0.1049) and not on `default_tuned`. + - **Fix.** Pick one rule and make the other match. Either propagate "underpowered" as a distinct walk outcome (for example `walked_value = NA`, with a `walk_status` of `underpowered at `), or change the doc. + +- **[severity: fragile]** data-raw/habitat_variants_build.R:83-90 and 428-429; data-raw/habitat_variants_score.R:383-384. The stamps record a commit SHA that does not contain the code that produced the schemas and the verdict. **Not inside a round-1 fix.** + - **In the build.** `--allow-dirty` lets it run with uncommitted changes, but the stamp does not say so. It records only `git rev-parse --short HEAD`. + - **In the score script.** There is no dirty check at all. The stamp also omits which `--variants` / `--roles` files were used, and their hashes. + - **Evidence from the pre-flight.** Both stamps read `link: 0.53.0 @ 823fde7`, and `git ls-tree 823fde7` contains neither `habitat_variants_build.R`, `habitat_variants_score.R` nor `R/lnk_habitat_validate_band.R`. + - **The pre-flight score used a trimmed variants file.** No `score284_bt_rear_0p1449` schema exists, and `bands.csv` has two steps. The stamp does not say so, and the ladder changes the core (`ladder_of()` intersects every variant schema). + - **Why it matters.** The build's own header says "A scored schema must be traceable to committed code and inputs." A full run launched with `--allow-dirty` would produce the same false pin. + - **Fix.** + - Write `dirty: yes/no` (the porcelain list) into both stamps. + - Add the same check, or the same record, to the score script. + - Record `path_variants` and `path_roles`, with their md5, in `stamp_score.txt`. + +- **[severity: fragile]** planning/active/task_plan.md Phase 4 post-conditions: "20 WSGs in `score284_default`; the 8 focal WSGs in each variant schema". **Not inside a round-1 fix.** + - **The real numbers.** `lnk_wsg_resolve(expand = TRUE)` on the 12 roles WSGs resolves to **23** WSGs (measured: LARL LFRA LPCE LSKE HARR KLUM KOTL UARL UPCE BULL KISP LILL PCEA REVL BULK CLRH ELKR MSKE PARA BABR MORR PARS BABL), and the research doc says 23. BT is active in all 12 roles WSGs, so every variant schema should hold **12** focal WSGs, not 8. + - **Why it matters.** Phase 4 explicitly verifies "against the DB, not the exit code". Checking against 20 and 8 would report a healthy build as failed, or accept a short one. + - **Fix.** Correct the expected counts before the full run. + +## Round-1 fixes: checked + +- **Fix 1 (access copied from base).** Holds. + - `copy_access()` names its columns and runs inside a transaction. + - The post-copy `SELECT *` digest compares row text in column order. A DDL order difference would stop the run loudly rather than pass it. Both schemas are sized by `lnk_persist_init(cfg$species)` from the same bundle, so they agree, and the pre-flight passed. + - `streams_access` is unique on `id_segment` per WSG (44,830 / 44,830 in both schemas), so `ORDER BY t.id_segment` is deterministic. +- **Fix 2 (per-WSG `base_recompute.csv`).** Holds. The first-run `old = NULL` path works (`rbind(NULL[...], rc)`), the file is no longer read as a gate, and the per-WSG update keeps other WSGs' rows. +- **Fix 3 (`species_of` / `aoi_of`).** Holds. + - These scope each variant exactly as the build does (`wsgs_v`), and `obs_key` compares like with like. + - The bands read `obs_base` (the `default` run at buffer 0). That is correct because the segmentation is shared. +- **Fix 4 (`attr(absences, "covered")`).** Holds. + - It reads the attribute from the unsubsetted frame, not from `a`, whose `[.data.frame` subset would have dropped it. + - The `ab` and `b` rows align: the same `aoi` and species, and the same sort. + +## Also checked and clean + +- **Pre-flight numbers reconcile with the DB and with each other.** + - Band km: 1121.21 − 1062.42 = 58.79, and 1150.59 − 1121.21 = 29.38. + - Counts: n_core 64 = `default`'s n_rearing, and 64 + 1 = the variant's 65. + - Bridge km sums: 20.78 + 26.35 + 11.66 = 58.79, and 12.87 + 12.22 + 4.28 = 29.38. + - An independent SQL check of `score284_bt_rear_0p1249` against `score284_default` for BULL: + - 0 spawning differences; + - 0 rearing removed; + - 58.788 km of rearing added; + - the same 44,830 segments. +- **The working schema now holds BT only.** `classify(species = BT)` replaced the whole working `streams_habitat`: 44,830 rows, all BT. The `default` re-classify re-creates every species before its digest check, so the invariant is not weakened. The table is unique on `(id_segment, species_code)`, so the digest order is deterministic. +- **Thresholds come from the variant bundle.** Classify and connect resolve them from `cfg` (`.lnk_habitat_thresholds_csv(cfg)`), not from the shared `loaded`, so passing `default`'s `loaded` to the variants is correct. Breaks are rebuilt in `.streams_breaks`, not in a shared schema. +- **The absence taxa CSV reproduces the old regexes.** `read.csv` leaves `\(` untouched, and the OR-join is equivalent. +- **The `habitat_validate.R` refactor leaves no dangling references.** +- **The UHC guard sees the right columns.** They are named `spawning` / `rearing`, coded integer 1 / −1 / −4 / NA, and there are no BT rows. The guard stops on any species row anywhere in BC, not only in focal WSGs. That is stricter than needed, but it fails loud. +- **`lnk_habitat_validate_band()`** matches round 1: + - full-key joins; + - identifier regexes before `sprintf`; + - a segmentation digest across every schema read; + - NA densities. diff --git a/planning/active/review-round3.md b/planning/active/review-round3.md new file mode 100644 index 00000000..eabf7217 --- /dev/null +++ b/planning/active/review-round3.md @@ -0,0 +1,100 @@ +# Code review, round 3: staged diff for #284 step 5 + +## Mechanism + +**A partial producer read by a whole-population reader.** Every earlier finding has one shape. An artifact is written over a *subset*: one species, one invocation's WSGs or variants, one row of the walk, or one moment of the tree. A reader then treats it as describing the *whole*: every species, every WSG, the whole ladder, or the code that actually ran. + +- **Round 1:** + - The variant `streams_access` holds one species, and the access check assumed it held all of them. + - `base_recompute.csv` covered one invocation and was read as covering all WSGs. + - A variant schema holds one species, and the score script validated it for every species. + - Absence rows cover some WSGs and were read as the surveyed set. +- **Round 2:** + - The walk anchored at `default` was read as the bundle verdict. + - A HEAD SHA was read as the code that ran. + - The plan's counts were read as the run. + +The candidate "two documents state one rule, edited separately" is a special case of this: a restatement is written once and read as if it tracked the other copy. Places this diff reaches, and the verdict for each: + +1. **`lnk_habitat_validate_band()` reading `streams_habitat_` in every schema.** The exported function assumes every schema holds every species. This diff creates schemas that hold one species. **Finding 2.** +2. **Score script, validation scoped per variant species** (round-1 fix, `species_of` / `aoi_of`). Holds. +3. **Score script, the walk: per row vs per ladder** (round-2 fix). **Finding 1.** +4. **Score script, the stamp's dirty pathspec vs the files it reads** (round-2 fix). The absence taxa CSV is not covered, and the check is taken at the end of the run where the build takes it at the start. **Finding 3.** +5. **Build stamp and bundles vs the schemas built.** + - The stamp hashes every bundle written, not the bundles whose schemas were built. + - `stamp_build_.txt` is overwritten per invocation, the same shape as the round-1 recompute CSV. + - The score script never cross-checks either. + - **Finding 4.** +6. **Build stamp `run_uid` line.** It is filled only if the operator exports `LNK_RUN_UID`. **Finding 5.** +7. **Plan vs research doc scope.** The plan still carries 7 schemas and a CH row. **Finding 6.** +8. **Research doc rule vs the code's rule.** The thresholds match: n ≥ 10, ratio ≥ 0.5, held-out and pooled, loosening means take when the band is habitat, and underpowered means the verdict stands. The doc/code split survives only through finding 1. +9. **`ladder_of()` / `core` vs doc ("rearing under every variant of the ladder").** Holds. + - The core is taken over `default` plus every variant with the same species and column. + - The nesting check (`against`) covers every row, in-sample included. +10. **README's "neither script names a species".** Holds: grep finds no species literal in either script's code. +11. **The absence `covered` set** (round-1 fix). Holds. +12. **The build's `wsgs_v` vs the score's `aoi_of`.** Both come from the same roles filter, so they agree. +13. **The `habitat_validate.R` refactor into `habitat_validate_inputs.R`.** It is a verbatim move, with the taxa CSV reproducing the regexes. Holds. +14. **The rule on a held-out-free subset.** It crashes rather than writing an empty verdict. **Finding 7** (low). + +## Findings + +- **[bug] data-raw/habitat_variants_score.R:298-332, inside the round-2 fix.** `walked_value` is computed per row, walking only up to that row's own step. So the rows of one ladder disagree, and every row except the outermost can report a value the rule does not give. + - **The header says otherwise.** The header (line 37) promises "the walked-out value per ladder". Phase 6 acts on `walked_value`. + - **Probed** with the walk block copied verbatim, in a scratch dir: + - **take, keep (n<10), take.** Row 1 reads `taken through bt_rear_0p1249`, **0.1249**. Rows 2 and 3 read underpowered, NA. The doc's answer is "0.1349 stands". A reader of row 1 would move `default_tuned` to 0.1249. + - **take, take, refuse.** Row 1 reads 0.1249, and rows 2 and 3 read 0.1349. The ladder answer is 0.1349. + - **take, refuse, take.** All rows read 0.1249, which is correct. + - **The cause.** The round-2 fix made "underpowered" a distinct outcome. It kept the loop over rows, where `chain` ends at `r$variant` rather than at the ladder's last step. + - **Fix.** Walk once per ladder, over the chain to its outermost variant in each direction. Write that one `walk_status` / `walked_value` on every row of the ladder, or as a separate ladder row. Keep the per-step `decision` as it is. + +- **[fragile] R/lnk_habitat_validate_band.R:114-176.** This is the exported function. It silently scores a species that a schema does not hold as if its habitat had been removed. + - **The guard does not cover it.** `.lnk_hvb_check_segmentation()` checks `streams` only. The per-schema `LEFT JOIN … coalesce(h.flag, false)` reads an **empty** `streams_habitat_` as "not habitat". + - **This diff creates exactly such schemas.** `lnk_persist_init(cfg$species)` creates every species' table, and the build persists one species into it. + - **Probed.** `lnk_habitat_validate_band(conn, "BULL", species = c("BT","RB"), flag = "rearing", schema = "score284_bt_rear_0p1249", schema_ref = "score284_default", …)` returns RB `removed` **694.25 km** with a core of 0 km, and no error. + - **Latent in the score script**, which passes only the step's species and that species' ladder. It is live for any caller of the exported API, and for a future ladder mixing species. + - **Fix.** Next to the segmentation check, stop when any schema has zero `streams_habitat_` rows for a WSG where `streams` has rows, or when its row count differs from `streams`. + +- **[fragile] data-raw/habitat_variants_score.R:397-406, inside the round-2 fix.** The dirty check describes neither the inputs nor the moment. + - **(a) Inputs.** The pathspec omits `data-raw/fiss_absence_taxa.csv`, which `hv_fiss_absences()` reads (`habitat_validate_inputs.R:16,73`) and which decides `n_absence_band`. An edited taxa file stamps clean. + - **(b) Moment.** `dirty` and `git rev-parse HEAD` run at the **end** of a long run. The build takes `dirty` at the start (`habitat_variants_build.R:84`), before `load_all()` output matters. + - A commit made mid-run stamps the score "clean @ " for code it did not run. + - The two copies of this logic were edited separately and diverged. + - **Fix.** + - Add the taxa CSV to the pathspec. + - Take the porcelain list and HEAD at the top of the script, before `load_all()` is used, and print them in the stamp. + - The build's `write_stamp()` also reads HEAD at the end (`:429`); read it with `dirty` at `:84`. + +- **[fragile] data-raw/habitat_variants_build.R:214-219, 416-419, 443; data-raw/habitat_variants_score.R:92-100.** The provenance of a scored schema is whatever bundle is on disk at score time. Nothing ties it to the invocation that built the schema. This is the round-1 `base_recompute.csv` shape again. + - **Bundles are rewritten on every invocation.** `write_bundle()` rewrites **every** variant's bundle on every invocation, including `--step=base` and `--only=`. + - **The stamp hashes every bundle, not every built one.** `write_stamp()` hashes all of `cfgs`, not `run_variants`. The pre-flight `stamp_build_all.txt` lists `bt_rear_0p1449=58e5ea82ebcb`, and no `score284_bt_rear_0p1449` exists. + - **The stamp file is overwritten per step.** `stamp_build_.txt` is overwritten per `--step`. So `--step=variants --only=A`, then `--only=B` (or a resume after a crash, since the stamp is written only on success), leaves a stamp that names B only. + - **The score script never cross-checks.** It loads `bundles/` and takes values from its own `--variants`, which in the pre-flight was a different, trimmed file. The step values, the bridge window and `walked_value` all come from that file. Nothing compares any of it to what the schema was built from. + - **Fix.** + - Hash only the variants built in the invocation, and append a per-invocation record rather than overwrite (or write per variant: `stamp_build_.txt`). + - In the score script, stop unless each `bundles//parameters_habitat_thresholds.csv` hash matches the build record for that schema. + +- **[low] data-raw/habitat_variants_build.R:420-423, 437-438.** The `run_uid` line reads `score284_default.log.run_uid`, which is NULL unless the operator exports `LNK_RUN_UID`. `lnk_pipeline_run()` only defaults to the env var. + - **In the DB:** all three pre-flight log rows have `run_uid` NULL. The stamp reads "none", and so does the plan's Phase 3 stamp item. + - **Fix.** `Sys.setenv(LNK_RUN_UID = )` at the top of the build when it is unset, or stamp `run_id` / `run_label` instead. + - **Also:** the format `"%slog"` renders as `score284_defaultlog` (a dot is missing). + +- **[low] planning/active/task_plan.md** ("Verification (end to end)" and Phase 5). These are stale against the revision, the round-2 class. + - "identical segmentation and access across **all 7 schemas**" should be 4. + - Phase 5 still lists "Question 3: the CH spawn 0.0299 band (3–4.5 %) as its own row". The research doc now says it is unscorable and CH is dropped, and nothing in the score script produces it. + - Phase 4 was corrected; these two were not. + +- **[low] data-raw/habitat_variants_score.R:289-302.** On a focal subset with no held-out WSG (for example `--wsgs=PARS`), `rule` has 0 rows. + - `rule$walk_status <- NA_character_` then errors ("replacement has 1 row, data has 0"; probed). + - `verdict.csv` and the stamp are never written, while `bands*.csv` are already on disk. + - It fails loud, but it leaves an output directory without the stamp that says what produced it. + - **Fix.** Guard with `if (nrow(rule) > 0L)`, or write the stamp before the rule. + +## Note (not a code defect) + +The pre-flight suggests the widened power table will shrink under the validator's filters. + +- **What the power table says.** `power_windows.txt` gives ELKR + BULL 10 locations in 0.1049–0.1249, with ELKR at most 5 there (6 in the whole window, 1 in 0.1249–0.1349). So BULL is at least 5 upper-bound. +- **What the pre-flight counted.** The BULL band for that step counted **n_band = 1**. +- **What that implies.** If the full set shrinks similarly, the 33 and 22 upper bounds for steps 2 and 3 may fall below n = 10, and the result is "0.1349 stands, underpowered". +- **Which makes finding 1 decisive.** That is exactly the case where the rows of `verdict.csv` currently disagree. diff --git a/planning/active/review-round4.md b/planning/active/review-round4.md new file mode 100644 index 00000000..9d85ff8c --- /dev/null +++ b/planning/active/review-round4.md @@ -0,0 +1,89 @@ +# Code review, round 4 (enumeration): staged diff for #284 step 5 + +Mechanism under test: **a partial producer read by a whole-population reader.** +Probes ran in the scratchpad (`r4/gap.R`) and read-only against docker fwapg; no repo +file other than this one was touched. + +## Enumeration + +| # | place | verdict | evidence | +|---|---|---|---| +| 1 | `lnk_habitat_validate_band()` reading `streams_habitat_` in every schema | **HOLDS** | `.lnk_hvb_check_habitat()` (R/lnk_habitat_validate_band.R:117, 226-247). Round 3's probe re-run on the pre-flight schemas (`species = c("BT","RB")`, `score284_bt_rear_0p1249` vs `score284_default`, BULL) now stops: `no habitat rows for: score284_bt_rear_0p1249.streams_habitat_rb:BULL`. The new test (test file :163-172) deletes BBBB rows and expects that error; without the check the call returns rows, so the test would go red. | +| 2 | score, validation scoped per variant species (`species_of` / `aoi_of`) | **HOLDS** | score.R:135-141, 146-148, 168-169. | +| 3 | score, the walk per ladder | **HOLDS for a complete, linear `--variants`; FAILS otherwise** | Pre-flight `verdict.csv`: both rows carry `ladder_tip = bt_rear_0p1349`, `underpowered at bt_rear_0p1249`, NA, so the rows agree. It fails when a `step_from` names a variant missing from `--variants`: `chain_to()` loops forever (Finding 1). A ladder that branches below `default` is overwritten by its last tip (Finding 5). | +| 4 | score, the stamp's dirty pathspec vs the files it reads | **Partly FAILS** | The taxa CSV was added and HEAD/dirty are now taken at launch (score.R:88-93), so both of those hold. It still omits `inst/extdata/wsg_regions.csv`, which decides pooling (Finding 3). | +| 5 | build stamp and bundles vs schemas built | **FAILS** | The round-3 fix narrowed the bundle writes to `run_variants`. It did not tie them to a built schema (Finding 2). | +| 6 | build stamp `run_uid` line and the `%slog` typo | **HOLDS** | The typo is fixed: build.R:444 reads `"%s.log"`. `run_uid` is an accepted tradeoff. | +| 7 | plan vs research doc scope | **HOLDS** | task_plan.md:45 names 4 schemas, :105 drops Question 3 with CH, and :126 reads "all 4 schemas". | +| 8 | research-doc rule vs code | **HOLDS** | Both use n ≥ 10, ratio ≥ 0.5, held-out and pooled. In both, an underpowered step means "no value, the step 1-4 verdict stands" (doc "Rule"; score.R:314-363). | +| 9 | `ladder_of()` / core | **HOLDS for a complete `--variants`** | With a trimmed file the core covers only the listed schemas. For this loosening ladder that makes no numeric difference, because the core is `default`'s rearing either way. The same trimmed-file case is behind Finding 1. | +| 10 | "neither script names a species" | **HOLDS** | A grep for quoted species codes in the build, score and inputs scripts finds nothing. | +| 11 | absence `covered` set | **HOLDS** | score.R:268-270 uses `attr(absences, "covered")`, the snapshot WSGs. | +| 12 | build `wsgs_v` vs score `aoi_of` | **HOLDS** | Both come from `intersect(focal, roles for sp)`. A score run with a different `--wsgs` than the build stops in `.lnk_hvb_check_segmentation()` ("no streams for"). | +| 13 | `habitat_validate.R` → `habitat_validate_inputs.R` move | **Behaviour HOLDS, provenance FAILS** | The regexes match the CSV one for one (`read.csv` keeps `\(`). But `habitat_validate.R`'s own dirty pathspec was not widened (Finding 4). | +| 14 | the rule on a subset with no held-out WSG | **HOLDS** | Probed: every assignment at score.R:314-338 succeeds on 0 rows, `tips` is empty, and `verdict.csv` and the stamp are written. | +| 15 (new) | `habitat_validate.R` stamp after the refactor | **FAILS** | Finding 4. | +| 16 (new) | `step_from` referential integrity in `--variants` | **FAILS** | Finding 1. | +| 17 (new) | build-time invariants (access copied from base, base-digest licence) read as holding at score time | **FAILS (low)** | Finding 6. | + +## Findings + +**[bug] data-raw/habitat_variants_score.R:224-232, 327-334: a `--variants` whose `step_from` names a variant it does not list hangs the score and mislabels every band.** New place, reached by the round-3 per-ladder walk. +- **Neither script checks that `step_from` is in `variant`.** + - The build's `stopifnot` (build.R:96-105) never reads `step_from`. + - The score has no structural check at all. +- **What a gap does, in order:** + 1. **The label goes wrong silently.** `value_of("bt_rear_0p1249", ...)` on a file without that row takes 0 rows. `identical(character(0), column)` is FALSE, so it returns `default`'s 0.1049. The band itself is still computed against `score284_bt_rear_0p1249`, which exists. So `value_from`, `direction`, `bands.csv` and `bridge_band.csv`'s `in_window` all carry the wrong origin value, and nothing says so. + 2. **The core shrinks** to the listed schemas (item 9). + 3. **`chain_to()` never ends.** `v <- variants$step_from[variants$variant == v]` becomes `character(0)`. `identical(character(0), "default")` is FALSE forever and `chain` stops growing. +- **Probed** (`scratchpad/r4/gap.R`) with the loop copied verbatim and an iteration guard added: `LOOPING; v = character(0)`. +- **Where it hits.** This is reached after every validation pass has run, and it hangs rather than failing. The pre-flight already used a trimmed file (`variants_pf.csv`), so trimmed files are how this script gets run. +- **A cycle in `step_from` hangs the same way.** +- **Fix.** Near score.R:77, `stopifnot(all(variants$step_from[!is.na(variants$column)] %in% variants$variant))`, and put the same check in the build's `stopifnot`. Bound `chain_to()` by `nrow(variants)`. + +**[fragile] data-raw/habitat_variants_build.R:215-224, 418-452; data-raw/habitat_variants_score.R:108-120: the round-3 fix does not make "a bundle on disk is the one its schema was built from" true.** Inside the round-3 fix (finding 4). The comment at build.R:216-217 claims it; four ways it fails: +- **`--step=base` rewrites every bundle.** + - The bundles are written before `step` is consulted. With no `--only`, `run_variants` is every variant, so a base-only invocation rewrites every variant bundle from the current `variants.csv` and builds no variant schema. + - Its stamp block then says `variants: ` and hashes them all. + - **Pre-flight evidence.** `bundles/bt_rear_0p1449/parameters_habitat_thresholds.csv` has mtime 17:59:02, the minute `closure.txt` and `base_recompute.csv` were written. `score284_bt_rear_0p1449` does not exist. +- **Bundles are written up front, before any schema is built.** A crash on variant 1 of 3 leaves bundles 2 and 3 describing values their schemas were never built from. Because the stamp is appended only on success (build.R:462), the crashed invocation leaves no record of either the bundles it rewrote or the schemas it did rebuild. +- **Bundles are never removed.** The pre-flight `bundles/bt_rear_0p1449` is left over from an earlier invocation. +- **The score's cross-check compares the bundle to `--variants`, and both can be newer than the schema.** + - **Nothing reads `stamp_build.txt`.** The score stamp records `--variants`' md5 but no bundle hash, so a reader cannot join a score to a build block. + - **Resume.** A resumed `--only=` appends a block naming only the rest. The variants rebuilt by the crashed run keep whatever older block last named them, which carries an older HEAD and hash. +- **The wrong-result path needs a value edit between invocations,** which the value-bearing variant names make unlikely. But this is exactly the path the fix was written to close. +- **Fix.** + - Write each bundle inside `run_variant()` rather than up front, and only when `step` includes variants. + - After a variant's digest checks pass, write a per-variant record: bundle sha256, HEAD, and time. Either `bundles//built.txt` or a one-row `.score_build` table. + - In the score, stop unless each bundle's sha matches that record, and print the shas in `stamp_score.txt`. + - **For the base:** the score reads `default`'s thresholds at score time (`thr_default`, `value_of`) and never compares them to the build. Add the build's own `n_diff == 1` test of each variant bundle against the *current* `default`, which catches a `default` edited since the build. + +**[fragile] data-raw/habitat_variants_score.R:90-93: the dirty pathspec still misses an input that decides `n_band`.** Inside the round-3 fix (finding 3a), one file over. +- **The file.** `hv_pooling()` → `lnk_species_pooling()` reads `inst/extdata/wsg_regions.csv` (R/lnk_species_pooling.R:82, 177-180). It decides which DV records pool into BT observations. +- **The package already treats it as a provenance input:** R/lnk_log.R:102-112 hashes it into the config hash for exactly this reason. +- **The pathspec covers `inst/extdata/configs` only,** so an uncommitted region edit stamps clean. The stamp's `pooling:` line hashes `species_pooling.csv` only. +- **Fix.** Widen `inst/extdata/configs` to `inst/extdata`, here and in the build's pathspec (harmless there). + +**[fragile] data-raw/habitat_validate.R:284-286: a regression from this diff.** New place, the sibling-caller shape ("a fix lands in one of two callers that share a harness"). +- **Before this diff,** the absence code and the taxa regexes lived in `habitat_validate.R`, so its pathspec `R inst/extdata/configs data-raw/habitat_validate.R` covered them. +- **The diff moved both out,** to `data-raw/habitat_validate_inputs.R` and `data-raw/fiss_absence_taxa.csv`, and did not widen that pathspec. The score's copy was widened; this one was not. +- **Result.** An uncommitted edit to either file changes #283's absence counts and stamps `habitat_validate_283` clean. +- **Pre-existing, same place:** it also omits `wsg_regions.csv`, and takes HEAD at the end (:308). +- **Fix.** Add `data-raw/habitat_validate_inputs.R`, `data-raw/fiss_absence_taxa.csv` and `inst/extdata` to the pathspec, and take HEAD and dirty at launch, as the score now does. + +**[low] data-raw/habitat_variants_score.R:335-363: a ladder that branches below `default` is mis-assigned.** +- **The assumption.** The comment (:322-323) allows branching only at `default`, and nothing checks it. +- **What breaks.** With A→A2 and A→A3, `tips` is {A2, A3}. Row A is written by both walks, and the last one wins, so A's `ladder_tip` / `walk_status` / `walked_value` describe only one of its two ladders. +- **Not live** with the current linear `variants.csv`. +- **Fix.** Stop if any non-base `step_from` value appears more than once. + +**[low] Build-time invariants read as holding at score time.** +- **Access.** `lnk_habitat_validate()` reads each variant's own `streams_access` (R/lnk_habitat_validate.R:674, 947). The equality with `score284_default` is asserted only at build (build.R:406-411), and the score never re-checks it. `run_base()` re-runs `lnk_access(merge = TRUE)` on every `--step=base|all` invocation, so a base pass after the variants can move base access while the variant copies stay put. Capture differences would then mix access into threshold effects. + - The band function is safe: it reads no access, and its segmentation check stops on a mismatch. + - **Fix.** Repeat the `streams_access` digest comparison per variant × WSG at the top of the score. +- **Base licence.** The base re-classify digest licence (build.R:388-396) runs only when `default` is in `run_variants`. A later `--only=` invocation, possibly at another HEAD, builds variants under no licence of its own. Note only. + +## Note + +- **Any stop after score.R:156 leaves partial outputs.** This includes the observation-key mismatch, UHC, the band checks and `against`. The output dir is left holding `summary.csv` / `totals.csv` / `bands*.csv` from this run and no `stamp_score.txt`. +- **That fails loud:** the exit is non-zero and the stamp is absent. Round 3's finding 7 fixed the one case that could not fail loud. diff --git a/planning/active/review-round5.md b/planning/active/review-round5.md new file mode 100644 index 00000000..8c196506 --- /dev/null +++ b/planning/active/review-round5.md @@ -0,0 +1,128 @@ +# Code review, round 5 (enumeration): staged diff for #284 step 5 + +Mechanism under test: **a partial producer read by a whole-population reader.** +Probes ran in `scratchpad/r5/` and read-only against docker fwapg (`score284_*`, +`working_score_bull`). No repo file other than this one was touched. + +## Round-4 fixes, re-checked for a defect inside each + +| fix | verdict | evidence | +|---|---|---| +| 1. ladder validation, bounded `chain_to` | **HOLDS** | The real 4-row `variants.csv` passes all three checks (probed: every `step_from` listed, `anyDuplicated(below) == 0`, walk terminates). A NA `step_from` on a non-base row stops ("names no listed variant: NA"). A self-loop and a two-cycle both stop. | +| 2. bundles written in `run_variant()`, `built.csv` sha, score cross-check | **HOLDS per variant, FAILS per WSG** | See Finding 2. `record_built()` on first write: `NULL[logical(0), , drop = FALSE]` is `NULL`, and `rbind(NULL, row)` is `row` (probed). | +| 3. score dirty pathspec widened to `inst/extdata` | **HOLDS** | score.R:116-119. The build reads nothing in link's `inst/extdata` outside `configs/` (`wsg_regions.csv` is pooling, which is score-only), so its narrower pathspec is right. | +| 4. `habitat_validate.R` pathspec and HEAD at launch | **Pathspec HOLDS, timing FAILS (low)** | HEAD is taken at launch (:99), but `link_dirty` is still computed at the end (:286). See Finding 4. | +| 5. branching ladders rejected | **HOLDS** | Same as 1. | +| 6. score re-checks access digest per variant × WSG; base re-classify in every variants pass | **HOLDS** | The licence runs over the same `focal` as every variant's `wsgs_v` in that pass, so each WSG a variant builds is licensed in the same pass. With the base working schema dropped, `--step=variants` stops at build.R:426-428 ("run --step=base first"). `run_base()`'s `done` check then re-runs that WSG, because it requires the working schema for focal WSGs (:310-311). The loop does not deadlock. | + +## Enumeration + +For every artifact the build writes: its writers, and each reader in the build and score. + +| # | artifact | writer (scope written) | reader | can the reader take a subset for the whole? | +|---|---|---|---|---| +| 1 | `default` schema (streams, habitat, barriers, access, log) | `run_base()`, per closure WSG. Access is re-settled for the invocation's `focal` only. | build `run_base()` resume `done` (:306-311) | **FAILS** (Finding 1). `done` reads the DB, which pre-flight and earlier invocations have filled. The licence data it needs lives in the `--out` directory. `done` cannot tell a WSG built by *this* build from one built by another invocation, dirty tree included. | +| 1 | 〃 | 〃 | build `run_variant()` streams / access digests (:454-459) | **HOLDS**: compared per WSG. | +| 1 | 〃 | 〃 | build `copy_access()` | **HOLDS**: per WSG, same column set asserted. | +| 1 | 〃 | 〃 | build `write_stamp()` `run_uid` from `.log` | **FAILS (low)**, part of Finding 1. It reads the log for focal WSGs, but never the log's `link_sha` / `link_dirty`. A resumed dirty-built WSG sits under a stamp line reading clean HEAD. | +| 1 | 〃 | 〃 | score: `digest_access`, `lnk_habitat_validate`, band ref/core, `abs_obs`, bridge `sr` | **HOLDS** for presence and segmentation. A WSG missing from every schema stops in `.lnk_hv_check_schema()` ("not persisted in …streams"). Access `NA`-vs-`NA` equality cannot mask that. | +| 2 | `working_score_` | `run_base()` for focal WSGs; overwritten by each `run_variant()` classify/connect | build `done` check (existence of `streams`) | **HOLDS**: `done` also needs base access rows, which persist last in `lnk_pipeline_run()`. | +| 2 | 〃 | 〃 | build `run_variant()` classify / `working_habitat_digest` / persist source | **HOLDS**. The working table ends a pass at the last variant's BT value. The base re-classify always runs first in the next pass and restores every species, and the licence digest proves it. | +| 3 | `` schemas | `run_variant()`, for `wsgs_v` of that invocation | build digest checks (written then checked) | **HOLDS**. | +| 3 | 〃 | 〃 | score access-digest loop (:184-194), validator, band fn, bridge | **HOLDS for presence and segmentation; FAILS for threshold provenance per WSG** (Finding 2). Read-only probe of the BULL pre-flight: spawning is identical base vs `bt_rear_0p1249` on 44,830 segments, and 0 rearing segments are removed, so the one-species re-classify path adds nothing beyond the step. | +| 4 | `bundles//` | `run_variant()`, before its WSG loop | build `cfgs` | **HOLDS**. | +| 4 | 〃 | 〃 | score `cfg_of`; sha vs `built.csv`; `n_diff` vs current default; value check | **HOLDS per variant.** If a crash lands between the bundle write and `record_built()`, the sha check catches a changed value. An unchanged value leaves the schema consistent. Per WSG: Finding 2. | +| 5 | `built.csv` | `record_built()`: one row per variant, **replaced by the latest invocation**, which may cover a `--wsgs` subset | score (:140-172) | **FAILS** (Finding 2). The score reads only `variant` and `thresholds_sha256`. It never reads `wsgs`, `schema`, `link_head` or `dirty`. | +| 6 | `base_habitat_digest.csv` | `run_base()`, per focal WSG **that this `--out`'s base runs built** | build `run_variant(default)` licence (:436-444) | **FAILS** across `--out` directories (Finding 1). HOLDS within one directory. | +| 7 | `base_recompute.csv` | `run_base()`, per-WSG merge | none in code | **HOLDS**: a labelled report, merged per WSG. First-write `NULL` path probed OK. | +| 8 | `closure.txt` | `run_base()`, overwritten with *this invocation's* closure | none in code | **HOLDS for code.** Note: a `--wsgs` subset base pass overwrites the full closure. Phase 4's "23 WSGs in `score284_default`" must be checked from the DB, not from this file. | +| 9 | `stamp_build.txt` | appended per **successful** invocation | none in code | **FAILS (low)**, Finding 3. Nothing joins a score to the build it verified. | +| 10 | score outputs (`summary.csv` … `stamp_score.txt`) | score; unlinked at score start | build | **FAILS (low)**, Finding 3. The build never clears them, so a later build into the same `--out` leaves them beside a `built.csv` they never read. | + +## Findings + +### [bug] Finding 1: the planned full build will stop at the licence for BULL, and would otherwise stamp a dirty-built base as clean + +**Location:** data-raw/habitat_variants_build.R:305-315, 416, 436-444, 473-476, 484-486. **Inside round-4 fix 6**: the licence now runs in every pass, so this path is reached on every variants pass. + +**Mechanism.** One build is keyed by two independent stores. +- The DB schemas are keyed by `--prefix`. +- The licence digests, bundles and `built.csv` are keyed by `--out`. +- `run_base()`'s resume test reads only the DB, while the licence reads only the `--out` file. + +**The live case: the pre-flight left its state in both stores.** +- **DB:** `score284_default` holds BULL, KOTL and LARL, and `working_score_bull` survives. Checked: `to_regclass('working_score_bull.streams')` is `t`, and BULL and LARL access rows are `t`. +- **Files:** the licence digest went to `scratchpad/preflight/base_habitat_digest.csv`. +- **Default `--out`:** `data-raw/logs/habitat_score_284/` holds only `power_windows.*`. + +**What happens on launch.** The task plan's full build (`--prefix=score284_`, default `--out`, 12 focal WSGs) runs as follows: +1. `run_base()` marks BULL `done` and skips it. LARL is skipped the same way. +2. KOTL is re-run, because it is focal now and its working schema was cleaned up. +3. `run_variant(default)` licenses ELKR. +4. At BULL, `want` is `character(0)`. The probe gave `length(want) == 0` and `identical(dg, want)` FALSE. +5. It stops with "gave habitat digest …, not the base run's : the re-classify path is not a pure threshold change". That is a misdiagnosis: the digest was never recorded here. +6. A relaunch stops identically, because BULL stays `done`. The ~75 min base has completed by then. + +**Provenance, even if the stop is avoided.** +- LARL and BULL keep bases built at `823fde7` with `link_dirty = t` (`score284_default.log`: all three rows are `t`). The pre-flight ran `--allow-dirty`. +- The build's clean-tree gate (:84-91) is bypassed by resume. +- `stamp_build.txt` would read `link @ ` with no "dirty". Its `run_uid` line reads the log but not `link_sha` / `link_dirty`. +- LARL is non-focal but lies downstream of KOTL and BULL, so its barriers feed their access. + +**Fix.** Before launch: +- Drop the pre-flight state (`score284_*` and `working_score_bull`). That is a separate asked step per task_plan.md:130, so ask now. +- Or re-point the full build's `--out` at the pre-flight directory. That does not fix the dirty LARL/BULL bases. + +In code: +- **(a)** Make `done` for a focal WSG also require its row in `path_base_digest`. A missing row re-runs the base WSG, which is safe because every variant is rebuilt in the pass after it. +- **(b)** Refuse to resume a WSG whose latest `.log` row has `link_dirty` or a `link_sha` other than HEAD while the run is clean. At minimum, print those per WSG in the stamp. +- **(c)** When `want` has length 0, say "no base digest for w in ". + +### [fragile] Finding 2: `built.csv` is one row per variant, written by a `--wsgs` subset and read as covering the score's whole aoi + +**Location:** data-raw/habitat_variants_build.R:250-269, 463; data-raw/habitat_variants_score.R:148-159. **Inside round-4 fix 2.** Round 5's question 1, answered yes. + +**What the record holds.** +- `record_built(v)` replaces the variant's row with this invocation's `wsgs`, `link_head`, `dirty` and sha. The rows for the WSGs it did not rebuild are dropped. +- The score keys on `variant` alone and reads only `thresholds_sha256`. `wsgs` and `schema` are written and never read. +- Probe: the pre-flight `built.csv` (`wsgs = BULL` on all three rows) passes the score's built check unchanged for the 12-WSG aoi. + +**What the score's checks cannot see.** +- None of the three checks sees a WSG built from a different bundle than the one `built.csv` now names: + - the sha vs the bundle on disk; + - the bundle = current default + one cell; + - the access digest, since access does not depend on thresholds. +- **Example.** Build 12 WSGs, then correct a `variants.csv` value (or `default`'s BT row, plus a base re-run of one WSG) and rebuild `--wsgs=ELKR`. The score passes and labels 11 WSGs with a value they were not built from. +- **No incidental guard.** The segmentation and access checks catch schema-shape drift, not threshold drift. +- **Same on the base row.** `default`'s row names only the licence invocation's `focal`. + +**Fix.** +- Write one row per variant × WSG, keyed `(variant, watershed_group_code)`. Replace only the rows rebuilt. +- In the score, stop unless every `(v, w in aoi_of(species_of(v)))` has a row and all of a variant's rows share one sha. +- Also check `b$schema == schema_of(v)`. `--prefix` and `--out` are independent, so a score can validate bundle X and score schema Y. + +### [fragile] Finding 3: the score's stamp does not name the build it verified + +**Location:** data-raw/habitat_variants_score.R:501-527; habitat_variants_build.R:467-501. **Inside round-4 fix 2**: round 4 recommended printing the shas in `stamp_score.txt`, and this was not done. + +**What `stamp_score.txt` omits.** +- It carries the score's own HEAD and `--variants` md5. +- It carries no bundle sha and no build `link_head` / `dirty` / `built_at`. + +**Consequences.** +- The pre-flight's stamp reads `823fde7 (dirty)` for the score, but nothing in it says the schemas were also built dirty. +- The build never unlinks the score outputs. A rebuild into the same `--out` therefore leaves `verdict.csv` / `summary.csv` beside a newer `built.csv` and `stamp_build.txt` block, with no join key between them. + +**Fix.** Copy the `built.csv` rows the score checked into `stamp_score.txt`: variant, schema, sha (12), `link_head`, `dirty`, `wsgs`, `built_at`. + +### [low] Finding 4: `habitat_validate.R` takes HEAD at launch and `dirty` at the end + +**Location:** data-raw/habitat_validate.R:99 vs 286-289. **Inside round-4 fix 4.** + +**What is wrong.** The stamp pairs launch HEAD with end-of-run dirtiness. A tree dirty at launch and committed mid-run stamps `` clean. The score script and the build both take the two together at launch. + +**Fix.** Move the `link_dirty` block up beside `head_sha` at :99. + +## Note + +`digest_sql$streams_access` (build.R:276) and `digest_access` (score.R:177) hash `t::text`. That depends on column **order**, while `copy_access()` asserts only `setequal`. A future order difference fails loud, as a false "differs from" at build or score. It cannot fail silently, and the pre-flight shows the orders match today. diff --git a/planning/active/task_plan.md b/planning/active/task_plan.md index 7a2cf108..95cc0c1c 100644 --- a/planning/active/task_plan.md +++ b/planning/active/task_plan.md @@ -26,67 +26,75 @@ Decisions taken at this gate (2026-09-29): - The literature veto stands. - In-sample WSGs are reported beside the verdict and never decide it. -## Run decisions (stated here, restated above the launch command) - -- **config:** `default`, plus six thin variant bundles that `extends: default` and override only `parameters_habitat_thresholds.csv` and `pipeline.schema`. Not `bcfishpass`. -- **schemas:** `score284_`, 7 new schemas. `fresh_default` and `fresh` are untouched. -- **focal WSGs:** ELKR, BULL, PARS, KOTL, BULK, MORR, UNTH, LNTH. -- **closure:** `lnk_wsg_resolve(expand = TRUE)` gives 20 WSGs. It adds LARL, LFRA, LPCE, LSKE, HARR, KLUM, UPCE, FRCN, KISP, PCEA, PARA and THOM, 461k source segments. - - The closure is modelled downstream-first into `score284_default` only. - - Only the 8 focal WSGs are re-classified per variant. -- **species:** `cfg$species` × presence. The pilots carry BT everywhere and CH in BULK, MORR, UNTH and LNTH. -- **flags:** `dams = TRUE`, `mapping_code = FALSE`, `log = TRUE` on the base run. The post-model access recompute runs on the focal WSGs. No primitives refresh. -- **variants** (`data-raw/habitat_score/variants.csv`): `default`, `default_tuned` (BT rear 0.1349), BT rear 0.1249 and 0.1449, CH spawn 0.0549 and 0.0299, CH rear 0.0649. -- **roles** (`wsg_roles.csv`): - - BT: held out ELKR and BULL; in sample PARS, KOTL, BULK and MORR. - - CH: held out UNTH and LNTH; in sample BULK and MORR. -- **Measured cost basis:** m1 0.0391 min per 1000 persisted segments, with persisted ≈ 3.5× source. - - Base run ≈ 1 h. - - Six re-classify passes over 206k source segments ≈ 1–1.5 h. - - Disk: `fresh_default` is 7 GB for 55 WSGs; about 15 GB here, against 981 GB free. +## Revision after the plan review (2026-09-29, operator's call) + +The review (`review-plan.md`) counted held-out observation locations per band window, and a +re-derivation confirmed it (`data-raw/logs/habitat_score_284/power_windows.txt`). The first +held-out set gave BT 10 / 1 / 0 and CH 0 / 1 / 2, so the rule could not decide five of six +steps. Decided: +- **BT only.** The held-out set is widened to ELKR, BULL, UARL, REVL, CLRH, LILL, BABL and + BABR (43 / 33 / 22 upper-bound locations). CH is dropped, and its verdicts stay "keep", + unscored. +- **An underpowered step (n < 10) changes nothing.** `default_tuned`'s 0.1349 stands. +- The core excludes nothing forced: BT has no `user_habitat_classification` rows. The score + script stops if a scored species does. + +## Run decisions (restated above the launch command) + +- **config:** `default`, plus three thin variant bundles (`extends: default`, one threshold cell and `pipeline.schema` overridden, own provenance checksum). Not `bcfishpass`. +- **schemas:** `score284_default`, `score284_bt_rear_0p1249`, `score284_bt_rear_0p1349` and `score284_bt_rear_0p1449`. `fresh_default` and `fresh` are untouched. +- **focal WSGs:** held out ELKR, BULL, UARL, REVL, CLRH, LILL, BABL, BABR; in sample PARS, KOTL, BULK, MORR. +- **closure:** `lnk_wsg_resolve(expand = TRUE)` gives 23 WSGs and 552k source segments (309k focal), modelled downstream-first into `score284_default` only. Only the 12 focal WSGs are re-classified. +- **species:** base = `cfg$species` × presence; variants classify BT only. +- **flags:** `dams = TRUE`, `mapping_code = FALSE`, `log = TRUE` on the base run; logged access recompute (`lnk_access(merge = TRUE)`) on the focal WSGs after the whole closure; no primitives refresh. +- **Cost basis:** m1 0.0391 min per 1000 persisted segments, with persisted ≈ 3.5× source. Base ≈ 75 min; 4 re-classify passes (the default invariant plus 3 BT variants) of the 12 focal WSGs, BT-only for the variants. ## Phase 1: Inputs as data -- [ ] `data-raw/habitat_score/variants.csv`: `variant, species_code, column, value, flag (spawning|rearing), obs_stage, tighter` (the ladder neighbour; `default` has none). Seven rows. No species is named in code. -- [ ] `data-raw/habitat_score/wsg_roles.csv`: `watershed_group_code, species_code, role (held_out|in_sample)`. -- [ ] `data-raw/fiss_absence_taxa.csv`: `species_code, role (caught|maybe), pattern`. It replaces the hard-coded `caught` / `maybe` regex lists in `data-raw/habitat_validate.R:170-177`. -- [ ] Extract the absence loader and the pooling resolution from `habitat_validate.R` into `data-raw/habitat_validate_inputs.R` (functions, sourced), so the scoring script uses the same code path rather than a copy. -- [ ] Verify with `LNK_KNOWLEDGE_DIR` set: re-run `habitat_validate.R --bundles=default:fresh_default,bcfishpass:fresh`. The CSVs in `data-raw/logs/habitat_validate_283/` must be byte-identical, `stamp.txt` aside. Also confirm that the absence counts would change with a taxa row removed (the guard fires). -- [ ] Write the rule, the band definition and the stage choice into `research/habitat_thresholds.md` §Step 5, **committed before any run**. +- [x] `data-raw/habitat_score/variants.csv`: `variant, species_code, column, value, flag (spawning|rearing), obs_stage, step_from` (the ladder neighbour nearer `default`), `equals_bundle`. Four rows after the revision (BT only). No species is named in code. +- [x] `data-raw/habitat_score/wsg_roles.csv`: `watershed_group_code, species_code, role (held_out|in_sample)`. +- [x] `data-raw/fiss_absence_taxa.csv`: `species_code, role (caught|maybe), pattern`. It replaces the hard-coded `caught` / `maybe` regex lists in `data-raw/habitat_validate.R:170-177`. +- [x] Extract the absence loader and the pooling resolution from `habitat_validate.R` into `data-raw/habitat_validate_inputs.R` (functions, sourced), so the scoring script uses the same code path rather than a copy. +- [x] Verify with `LNK_KNOWLEDGE_DIR` set (knowledge pinned at `508bf44` through `git archive`: all 6 CSVs byte-identical; the BT absences go 1535 → 1539 with the DV row removed): re-run `habitat_validate.R --bundles=default:fresh_default,bcfishpass:fresh`. The CSVs in `data-raw/logs/habitat_validate_283/` must be byte-identical, `stamp.txt` aside. Also confirm that the absence counts would change with a taxa row removed (the guard fires). +- [x] Write the rule, the band definition and the stage choice into `research/habitat_thresholds.md` §Step 5, **committed before any run**. Revised after the power check, with its counts. ## Phase 2: `lnk_habitat_validate_band()` (exported) -- [ ] `R/lnk_habitat_validate_band.R`. Arguments: `conn, aoi, species, flag, schema, schema_ref, observations` (a `lnk_habitat_validate()$observations` frame), `stage`. -- [ ] The function returns, per WSG × species, the band as `schema \ schema_ref` and `schema_ref \ schema`: +- [x] `R/lnk_habitat_validate_band.R`. Arguments: `conn, aoi, species, flag, schema, schema_ref, observations` (a `lnk_habitat_validate()$observations` frame), `stage`. +- [x] The function returns, per WSG × species, the band as `schema \ schema_ref` and `schema_ref \ schema`: - `band_km` and `n_band` (stage-filtered observation locations on band segments); - the incumbent's km and n (`schema_ref`'s flag outside the band); - both densities and their ratio. -- [ ] Every join is on `(id_segment, watershed_group_code)`. Before counting, it fails loudly unless both schemas carry an identical segment set per WSG: an id_segment and length digest from `streams`. -- [ ] `tests/testthat/test-lnk_habitat_validate_band.R`, DB-gated like `test-lnk_habitat_validate.R`: +- [x] Every join is on `(id_segment, watershed_group_code)`. Before counting, it fails loudly unless both schemas carry an identical segment set per WSG: an id_segment and length digest from `streams`. +- [x] `tests/testthat/test-lnk_habitat_validate_band.R`, DB-gated like `test-lnk_habitat_validate.R`: - band arithmetic on a small constructed pair of schemas; - the guard erroring on mismatched segmentation, then restoring the defect and watching it go red; - the empty-band case (ratio `NA`, not 0); - the stage filter. -- [ ] A roxygen `@examples` block (`\dontrun`, DB), `@family compare`, `devtools::document()`, `pkgdown::check_pkgdown()`. + - Mutations run in a scratch copy: guard removed → 2 failures; bare `id_segment` join → failure cap hit. +- [x] `schema_core` (all ladder schemas) defines the core; the review found forced (UHC) reaches would bias it, which is documented at the score script, where it stops. +- [x] A roxygen `@examples` block (`\dontrun`, DB), `@family compare`, `devtools::document()`, `pkgdown::check_pkgdown()`. ## Phase 3: Variant build harness -- [ ] `data-raw/habitat_variants_build.R --variants= --roles= [--wsgs=] [--step=base|variants|all]`. It generates one thin bundle per variant into `data-raw/logs/habitat_score_284/bundles//` (`config.yaml` + thresholds CSV with checksum), loaded by path through `lnk_config()`. -- [ ] **Base run:** `lnk_pipeline_run()` for `default`, over the closure in `lnk_wsg_resolve()` order. +- [x] `data-raw/habitat_variants_build.R --variants= --roles= [--wsgs=] [--step=base|variants|all]`. It generates one thin bundle per variant into `data-raw/logs/habitat_score_284/bundles//` (`config.yaml` + thresholds CSV with checksum), loaded by path through `lnk_config()`. +- [x] **Base run:** `lnk_pipeline_run()` for `default`, over the closure in `lnk_wsg_resolve()` order. - `lnk_wsg_downstream_check()` runs before each WSG in error mode. - The working schemas are `working_score_`, with `cleanup_working = FALSE` for focal WSGs only. - The post-model access recompute (`lnk_access(merge = TRUE)`, as in `wsg_recompute_one.R`) runs on the focal WSGs. -- [ ] **Per variant × focal WSG:** +- [x] **Per variant × focal WSG:** - `lnk_pipeline_classify()` and `lnk_pipeline_connect()` on the working schema, then `lnk_persist_init()` and `lnk_pipeline_persist()` into `score284_`; - `streams_access` replaced with the rows from `score284_default`, since access does not depend on the habitat thresholds. -- [ ] **Invariants asserted after each variant:** + - Variants classify their own species only, and each WSG writes a `built.csv` row (bundle sha, HEAD, dirty) once its checks pass. +- [x] **Invariants asserted after each variant:** - the `streams` segment digest and the `streams_access` digest are identical to `score284_default` for every focal WSG; - re-classifying `default` reproduces the base run's `streams_habitat` digest. -- [ ] Stamp: link and fresh SHAs, `run_uid`, variant bundle hashes, source counts and the bcfishobs row count. -- [ ] Pre-flight on BULL (smallest, 13k source segments) with `default` and `default_tuned`. The invariants must hold and the BT band must be non-empty, framed against `fresh_default` and `fresh` where they exist. +- [x] Stamp (appended per invocation): link and fresh SHAs, `run_uid`, variant bundle hashes, source counts and the bcfishobs row count. +- [x] Pre-flight on BULL (closure LARL, KOTL, BULL; output to scratchpad). The default re-classify reproduced the base digest (`140b63de`). The bands reconcile with the rollup to 0.01 km: 1062.42 → 1121.21 → 1150.59, bands 58.79 and 29.38. BULL is in neither `fresh` nor `fresh_default`, so there is nothing to frame it against. It surfaced one defect at run time (the access check), which code-check round 1 had also found. +- [x] `/code-check`: 5 rounds and an enumeration (`review-round1..5.md`, `review-enumeration.md`). ## Phase 4: Full build - [ ] Restate the run decisions and launch detached (`nohup … & disown`). The repo is not touched while it runs. - [ ] Verify post-conditions against the DB, not the exit code: - - 20 WSGs in `score284_default`; - - the 8 focal WSGs in each variant schema; + - 23 WSGs in `score284_default`; + - the 12 focal WSGs in each variant schema (BT); - the invariants from Phase 3; - `.log` rows present for the base run. - [ ] Commit the run log and stamp to `data-raw/logs/habitat_score_284/` (redacted). @@ -96,7 +104,7 @@ Decisions taken at this gate (2026-09-29): - [ ] Bands per ladder step via `lnk_habitat_validate_band()` → `bands.csv`, which holds held-out and in-sample rows, the absence count in each band, and `n` and `density_ratio`. - [ ] Apply the rule mechanically → `verdict.csv` (per ladder step: pass, fail or keep with n < 10, then the walked-out value). - [ ] Question 2: the km of BT rearing newly admitted in each band that has spawning upstream (`fwa_upstream`) against bridge-only. Output: `bridge_band.csv`. -- [ ] Question 3: the CH spawn 0.0299 band (3–4.5 %) as its own row. +- [x] Question 3 (the CH spawn 0.0299 band): dropped with CH; the research doc records it as unscorable (0 held-out spawn-staged locations). ## Phase 6: Verdict and landing - [ ] Revise `research/habitat_thresholds.md` in place: @@ -117,8 +125,8 @@ Decisions taken at this gate (2026-09-29): ## Verification (end to end) - Phase 1: the #283 CSVs are byte-identical after the refactor. - Phase 2: the tests, with the guard shown to fire. -- Phases 3–4: the DB invariants (identical segmentation and access across all 7 schemas, and the default re-classify digest equal to the base run) are the proof that each band difference is purely a threshold effect. -- Phase 5: `bands.csv` n and km reconcile with `summary.csv` totals: the `default_tuned` minus `default` rearing km equals the sum of the BT 0.1249 and 0.1349 band km. +- Phases 3–4: the DB invariants (identical segmentation across all 4 schemas, access copied from the base, and the default re-classify digest equal to the base run) are the proof that each band difference is purely a threshold effect. +- Phase 5: `bands.csv` km reconcile with `summary.csv` rearing km: `score284_bt_rear_0p1349` minus `score284_default` equals the sum of the 0.1249 and 0.1349 band km (within the rollup's 0.01 km per WSG rounding). ## Out of scope - Dropping the `score284_*` schemas. They are kept until the verdict lands, and dropping them is a separate, asked step. From e873bd8baa1fbc28354836873ab6b01a601360ae Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 21:29:38 -0700 Subject: [PATCH 05/11] Score: taper and elevation diagnostics, and the expected-count floor beside the rule (#284) taper.csv gives observations per km along each ladder (the core cut into gradient bins, then each band); elevation.csv compares each band with the core inside the same elevation tercile of the WSG's own rearing, so a band's low rate can be separated from 'it is higher up' (temperature, size). The verdict of record keeps the fixed rule; beside it, the same floor applied to the locations a band would hold at the core's rate, which can refuse a band fish avoid. That second reading is under discussion and moves nothing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/habitat_variants_score.R | 182 ++++++++++++++++++++++++++---- 1 file changed, 157 insertions(+), 25 deletions(-) diff --git a/data-raw/habitat_variants_score.R b/data-raw/habitat_variants_score.R index b29589da..3249e157 100644 --- a/data-raw/habitat_variants_score.R +++ b/data-raw/habitat_variants_score.R @@ -37,6 +37,11 @@ # verdict.csv the rule per step, and the walked-out value per ladder # bridge_band.csv rearing km each added band holds with and without # spawning upstream +# taper.csv observations per km along each ladder: the core cut into +# gradient bins, then each band, against the core's rate +# elevation.csv each band against the core within the same elevation +# class (terciles of the WSG's own core rearing), so a +# band's low rate can be told apart from "it is higher up" # stamp_score.txt environment stamp suppressPackageStartupMessages({ @@ -108,7 +113,8 @@ roles <- roles[roles$watershed_group_code %in% focal, ] species <- sort(unique(roles$species_code)) schema_of <- function(v) paste0(prefix, v) outputs <- c("summary.csv", "totals.csv", "bands.csv", "bands_pooled.csv", - "verdict.csv", "bridge_band.csv", "stamp_score.txt") + "verdict.csv", "bridge_band.csv", "taper.csv", "elevation.csv", + "stamp_score.txt") unlink(file.path(dir_out, outputs)) # Taken at launch: the code that runs is the code at the start. @@ -398,6 +404,17 @@ rule$decision <- ifelse( rule$n_band < n_min, "keep (n < 10)", ifelse((rule$step_direction == "added") == rule$band_is_habitat, "take", "refuse")) +# Beside the rule, not in it: the same floor on the locations the band would +# hold at the core's rate (core density x band km), which is set by the band's +# length before any fish are counted. The rule's floor on the locations +# FOUND cannot refuse a band fish avoid (few found reads as "underpowered"); +# this reading can. Under discussion with the operator, 2026-09-29; the +# verdict of record is `decision`. +rule$n_expected <- rule$density_core * rule$band_km +band_is_dense <- !is.na(rule$density_ratio) & rule$density_ratio >= ratio_min +rule$decision_expected_floor <- ifelse( + is.na(rule$n_expected) | rule$n_expected < n_min, "keep (expected < 10)", + ifelse((rule$step_direction == "added") == band_is_dense, "take", "refuse")) # Walk each ladder out from default once, to its last step, and write that # one outcome on every row of the ladder. A ladder is the chain from default # to a tip (a variant no other variant steps from); a ladder that branches at @@ -415,37 +432,152 @@ chain_to <- function(v) { chain } tips <- setdiff(rule$variant, variants$step_from) -rule$ladder_tip <- rep(NA_character_, nrow(rule)) -rule$walk_status <- rep(NA_character_, nrow(rule)) -rule$walked_value <- rep(NA_real_, nrow(rule)) -for (tip in tips) { - chain <- chain_to(tip) - dec <- rule$decision[match(chain, rule$variant)] - stop_at <- which(dec != "take" | is.na(dec))[1] - r <- rule[rule$variant == tip, ] - if (is.na(stop_at)) { - status <- paste("taken through", tip) - value <- num(variants$value[variants$variant == tip]) - } else if (identical(dec[stop_at], "refuse")) { - status <- paste("refused at", chain[stop_at]) - value <- if (stop_at == 1L) { - value_of(base_variant, r$species_code, r$column) +walk <- function(decision) { + out <- data.frame(tip = rep(NA_character_, nrow(rule)), + status = rep(NA_character_, nrow(rule)), + value = rep(NA_real_, nrow(rule))) + for (tip in tips) { + chain <- chain_to(tip) + dec <- decision[match(chain, rule$variant)] + stop_at <- which(dec != "take" | is.na(dec))[1] + r <- rule[rule$variant == tip, ] + if (is.na(stop_at)) { + status <- paste("taken through", tip) + value <- num(variants$value[variants$variant == tip]) + } else if (identical(dec[stop_at], "refuse")) { + status <- paste("refused at", chain[stop_at]) + value <- if (stop_at == 1L) { + value_of(base_variant, r$species_code, r$column) + } else { + num(variants$value[variants$variant == chain[stop_at - 1L]]) + } } else { - num(variants$value[variants$variant == chain[stop_at - 1L]]) + status <- paste("underpowered at", chain[stop_at], + "- the step 1-4 verdict stands") + value <- NA_real_ } - } else { - status <- paste("underpowered at", chain[stop_at], - "- the step 1-4 verdict stands") - value <- NA_real_ + on <- rule$variant %in% chain + out$tip[on] <- tip + out$status[on] <- status + out$value[on] <- value } - on <- rule$variant %in% chain - rule$ladder_tip[on] <- tip - rule$walk_status[on] <- status - rule$walked_value[on] <- value + out } +w_rule <- walk(rule$decision) +rule$ladder_tip <- w_rule$tip +rule$walk_status <- w_rule$status +rule$walked_value <- w_rule$value +w_exp <- walk(rule$decision_expected_floor) +rule$walk_status_expected_floor <- w_exp$status +rule$walked_value_expected_floor <- w_exp$value utils::write.csv(rule, file.path(dir_out, "verdict.csv"), row.names = FALSE, na = "") +# -- diagnostics: the taper, and the band against the core by elevation ----------------- +# Per segment of the base network, for each ladder (species x column x flag): +# which step's band it is in (or the core, or neither), its gradient, its +# elevation (mean of the geometry's Z range) and the locations on it. Rates +# are pooled sums (locations / km) per role, never averages of segment rates. +ladders <- unique(steps[c("species_code", "column", "flag")]) +seg_rows <- list() +for (k in seq_len(nrow(ladders))) { + L <- ladders[k, ] + lad <- steps[steps$species_code == L$species_code & steps$column == L$column, ] + sch_all <- schema_of(ladder_of(L$species_code, L$column)) + w_sp <- roles$watershed_group_code[roles$species_code == L$species_code] + spl <- tolower(L$species_code) + joins <- paste(sprintf( + "LEFT JOIN %1$s.streams_habitat_%2$s h%3$d + ON h%3$d.id_segment = s.id_segment + AND h%3$d.watershed_group_code = s.watershed_group_code", + sch_all, spl, seq_along(sch_all)), collapse = "\n ") + flag_of <- function(sch) { + sprintf("coalesce(h%d.%s, false)", match(sch, sch_all), L$flag) + } + band_case <- paste(sprintf("WHEN %s <> %s THEN %s", + flag_of(schema_of(lad$variant)), + flag_of(schema_of(lad$step_from)), + DBI::dbQuoteString(conn, lad$variant)), + collapse = " ") + d <- dbGetQuery(conn, sprintf( + "SELECT s.watershed_group_code, s.id_segment, s.length_metre, s.gradient, + (st_zmin(s.geom) + st_zmax(s.geom)) / 2 AS elevation, + CASE WHEN %3$s THEN 'core' %4$s ELSE NULL END AS class + FROM %1$s.streams s + %2$s + WHERE s.watershed_group_code = ANY($1)", + schema_of(base_variant), joins, + paste(vapply(sch_all, flag_of, character(1)), collapse = " AND "), + band_case), params = list(paste0("{", paste(w_sp, collapse = ","), "}"))) + d <- d[!is.na(d$class), ] + o <- obs_base[obs_base$species_code == L$species_code & + !is.na(obs_base$id_segment), ] + st <- unique(lad$obs_stage) + if (identical(st, "spawn")) o <- o[o$is_spawn %in% TRUE, ] + if (identical(st, "rear")) o <- o[o$is_rear %in% TRUE, ] + n_seg <- table(paste(o$watershed_group_code, o$id_segment)) + d$n <- as.integer(n_seg[paste(d$watershed_group_code, d$id_segment)]) + d$n[is.na(d$n)] <- 0L + d$species_code <- L$species_code + d$column <- L$column + d$role <- roles$role[match(paste(d$watershed_group_code, d$species_code), + paste(roles$watershed_group_code, + roles$species_code))] + seg_rows[[k]] <- d +} +seg <- do.call(rbind, seg_rows) +pool_rate <- function(d, by) { + a <- stats::aggregate(cbind(km = d$length_metre / 1000, n = d$n), d[by], sum) + a$per_100km <- ifelse(a$km > 0, 100 * a$n / a$km, NA_real_) + a +} +# Taper: the core split into gradient bins, then each band as its own row. +grad_bins <- c(-Inf, 0.02, 0.05, 0.08, Inf) +seg$taper_class <- ifelse( + seg$class == "core", + paste0("core ", as.character(cut(seg$gradient, grad_bins, right = TRUE))), + paste0("band ", seg$class)) +taper <- pool_rate(seg, c("species_code", "column", "role", "taper_class")) +core_rate <- pool_rate(seg[seg$class == "core", ], + c("species_code", "column", "role")) +taper$ratio_to_core <- taper$per_100km / + core_rate$per_100km[match(paste(taper$species_code, taper$column, taper$role), + paste(core_rate$species_code, core_rate$column, + core_rate$role))] +utils::write.csv(taper[do.call(order, taper[c("species_code", "column", "role", + "taper_class")]), ], + file.path(dir_out, "taper.csv"), row.names = FALSE, na = "") +# Elevation: terciles of each WSG's own core elevation, length-weighted, so a +# band sits in the same low / mid / high classes as the rearing it joins. +seg$elev_class <- NA_character_ +for (w in unique(seg$watershed_group_code)) { + for (lad_key in unique(paste(seg$species_code, seg$column))) { + i <- seg$watershed_group_code == w & paste(seg$species_code, seg$column) == lad_key + core <- seg[i & seg$class == "core" & !is.na(seg$elevation), ] + if (nrow(core) == 0L) next + o <- order(core$elevation) + cw <- cumsum(core$length_metre[o]) / sum(core$length_metre) + cuts <- c(core$elevation[o][which(cw >= 1 / 3)[1]], + core$elevation[o][which(cw >= 2 / 3)[1]]) + seg$elev_class[i] <- as.character(cut(seg$elevation[i], + c(-Inf, cuts, Inf), + labels = c("low", "mid", "high"))) + } +} +elev <- pool_rate(seg[!is.na(seg$elev_class), ], + c("species_code", "column", "role", "class", "elev_class")) +elev_core <- elev[elev$class == "core", ] +elev$core_per_100km <- elev_core$per_100km[match( + paste(elev$species_code, elev$column, elev$role, elev$elev_class), + paste(elev_core$species_code, elev_core$column, elev_core$role, + elev_core$elev_class))] +elev$ratio_to_core <- elev$per_100km / elev$core_per_100km +elev$elev_class <- factor(elev$elev_class, c("low", "mid", "high")) +utils::write.csv(elev[do.call(order, elev[c("species_code", "column", "role", + "class", "elev_class")]), ], + file.path(dir_out, "elevation.csv"), row.names = FALSE, + na = "") + # -- question 2: added rearing with and without spawning upstream ------------------------- # .frs_cluster_both() keeps a rearing cluster with spawning anywhere upstream, # and otherwise only through the downstream bridge; this splits each added From fe7279f0e716b257e360aa8595fbbfb688a0b8b4 Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 21:41:23 -0700 Subject: [PATCH 06/11] Score: tolerate clustering's small against-direction moves, report them (#284) Loosening BT rear_gradient_max removed 1.1 km of rearing (BULK, KOTL, LILL) while adding 1,365 km: a newly admitted segment merging clusters. The nesting guard now stops only above 1 % of a step's length and the against-direction km stay in bands.csv. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/habitat_variants_score.R | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/data-raw/habitat_variants_score.R b/data-raw/habitat_variants_score.R index 3249e157..fe4cfb2d 100644 --- a/data-raw/habitat_variants_score.R +++ b/data-raw/habitat_variants_score.R @@ -370,14 +370,25 @@ bands$role <- roles$role[match( paste(roles$watershed_group_code, roles$species_code))] utils::write.csv(bands, file.path(dir_out, "bands.csv"), row.names = FALSE, na = "") -# A ladder step moves habitat one way. Anything moved the other way means the +# A ladder step moves habitat one way, except that clustering can drop a +# segment when a newly admitted one merges it into a different cluster +# (measured: 1.1 km against 1,365 km added across the BT steps). The +# against-direction length stays in bands.csv; the run stops only when it is +# more than 1 % of what the step moves the right way, which would mean the # ladder is not nested and the core is not "default outside every band". -against <- bands[bands$direction != bands$step_direction & bands$band_km > 0, ] -if (nrow(against) > 0L) { - stop("steps moved habitat against their direction (see bands.csv): ", - paste(unique(paste(against$variant, against$watershed_group_code)), - collapse = ", "), call. = FALSE) +b_any <- bands[bands$stage == "any", ] +with_km <- tapply(b_any$band_km[b_any$direction == b_any$step_direction], + b_any$variant[b_any$direction == b_any$step_direction], sum) +against_km <- tapply(b_any$band_km[b_any$direction != b_any$step_direction], + b_any$variant[b_any$direction != b_any$step_direction], sum) +share <- against_km / with_km[names(against_km)] +if (any(share > 0.01, na.rm = TRUE)) { + stop("steps moved more than 1 % of their habitat against their direction ", + "(see bands.csv): ", paste(names(share)[share > 0.01], collapse = ", "), + call. = FALSE) } +message("habitat moved against the step direction (km): ", + paste(names(against_km), round(against_km, 3), collapse = ", ")) key_b <- c("variant", "step_from", "column", "value_from", "value", "step_direction", "obs_stage", "species_code", "flag", "role", From 031c5cc6affc4e3ac01a3704b038fbc442de9bed Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 21:53:23 -0700 Subject: [PATCH 07/11] Score: elevation-adjusted band ratio (#284) Core BT rearing thins with elevation (24.6 / 19.3 / 10.2 locations per 100 km, low / mid / high terciles, held out) and the steep bands sit mostly high, so the pooled ratio charges gradient for elevation. The adjusted ratio compares found locations with those the core's rate predicts in the band's own elevation mix. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/habitat_variants_score.R | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/data-raw/habitat_variants_score.R b/data-raw/habitat_variants_score.R index fe4cfb2d..906ff1b7 100644 --- a/data-raw/habitat_variants_score.R +++ b/data-raw/habitat_variants_score.R @@ -42,6 +42,8 @@ # elevation.csv each band against the core within the same elevation # class (terciles of the WSG's own core rearing), so a # band's low rate can be told apart from "it is higher up" +# elevation_adjusted.csv per band: found / expected at the core's rate in +# the band's own elevation mix # stamp_score.txt environment stamp suppressPackageStartupMessages({ @@ -114,7 +116,7 @@ species <- sort(unique(roles$species_code)) schema_of <- function(v) paste0(prefix, v) outputs <- c("summary.csv", "totals.csv", "bands.csv", "bands_pooled.csv", "verdict.csv", "bridge_band.csv", "taper.csv", "elevation.csv", - "stamp_score.txt") + "elevation_adjusted.csv", "stamp_score.txt") unlink(file.path(dir_out, outputs)) # Taken at launch: the code that runs is the code at the start. @@ -588,6 +590,18 @@ utils::write.csv(elev[do.call(order, elev[c("species_code", "column", "role", "class", "elev_class")]), ], file.path(dir_out, "elevation.csv"), row.names = FALSE, na = "") +# One number per band: locations found against those expected if the band +# held the core's rate in each of its own elevation classes (sum of band km x +# core rate, class by class). It removes "the band is higher up" from the +# pooled ratio; it does not remove temperature or size within a class. +eb <- elev[elev$class != "core", ] +eb$expected <- eb$km * eb$core_per_100km / 100 +adj <- stats::aggregate(cbind(km, n, expected) ~ species_code + column + role + + class, eb, sum) +adj$ratio_elevation_adjusted <- ifelse(adj$expected > 0, adj$n / adj$expected, + NA_real_) +utils::write.csv(adj, file.path(dir_out, "elevation_adjusted.csv"), + row.names = FALSE, na = "") # -- question 2: added rearing with and without spawning upstream ------------------------- # .frs_cluster_both() keeps a rearing cluster with spawning anywhere upstream, From 495918a960b9e6770b471f3490a549df20c131c2 Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 22:06:52 -0700 Subject: [PATCH 08/11] #284 step 5 results: BT rear_gradient_max 0.1349 scored and held (#284) Run 20260930_014921-53610765 (23-WSG closure, 3 BT variants, 12 focal WSGs). Held out, the steps to 0.1349 add rearing BT use at 0.60 and 0.71 of the core rate (0.75 and 0.89 at the same elevation); the step to 0.1449 does not (8 found, 25 expected). default_tuned is unchanged and no longer described as unscored. Evidence under data-raw/logs/habitat_score_284/; results in research/habitat_thresholds.md, Step 5. Weights instead of cutoffs went to NewGraphEnvironment/knowledge#28. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- CLAUDE.md | 30 + data-raw/logs/habitat_score_284/bands.csv | 217 + .../logs/habitat_score_284/bands_pooled.csv | 37 + .../habitat_score_284/base_habitat_digest.csv | 13 + .../logs/habitat_score_284/base_recompute.csv | 13 + .../logs/habitat_score_284/bridge_band.csv | 110 + .../build_20260930_014921-53610765.log | 20988 ++++++++++++++++ data-raw/logs/habitat_score_284/built.csv | 49 + .../bundles/bt_rear_0p1249/config.yaml | 13 + .../parameters_habitat_thresholds.csv | 12 + .../bundles/bt_rear_0p1349/config.yaml | 13 + .../parameters_habitat_thresholds.csv | 12 + .../bundles/bt_rear_0p1449/config.yaml | 13 + .../parameters_habitat_thresholds.csv | 12 + data-raw/logs/habitat_score_284/closure.txt | 23 + data-raw/logs/habitat_score_284/elevation.csv | 25 + .../habitat_score_284/elevation_adjusted.csv | 7 + .../logs/habitat_score_284/stamp_build.txt | 11 + .../logs/habitat_score_284/stamp_score.txt | 15 + data-raw/logs/habitat_score_284/summary.csv | 289 + data-raw/logs/habitat_score_284/taper.csv | 15 + data-raw/logs/habitat_score_284/totals.csv | 49 + data-raw/logs/habitat_score_284/verdict.csv | 4 + inst/extdata/configs/default_tuned/README.md | 2 +- .../extdata/configs/default_tuned/config.yaml | 5 +- planning/active/findings.md | 6 + planning/active/progress.md | 3 + planning/active/task_plan.md | 22 +- research/habitat_thresholds.md | 63 +- research/habitat_validation.md | 27 +- 30 files changed, 22066 insertions(+), 32 deletions(-) create mode 100644 data-raw/logs/habitat_score_284/bands.csv create mode 100644 data-raw/logs/habitat_score_284/bands_pooled.csv create mode 100644 data-raw/logs/habitat_score_284/base_habitat_digest.csv create mode 100644 data-raw/logs/habitat_score_284/base_recompute.csv create mode 100644 data-raw/logs/habitat_score_284/bridge_band.csv create mode 100644 data-raw/logs/habitat_score_284/build_20260930_014921-53610765.log create mode 100644 data-raw/logs/habitat_score_284/built.csv create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/config.yaml create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/parameters_habitat_thresholds.csv create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/config.yaml create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/parameters_habitat_thresholds.csv create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/config.yaml create mode 100644 data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/parameters_habitat_thresholds.csv create mode 100644 data-raw/logs/habitat_score_284/closure.txt create mode 100644 data-raw/logs/habitat_score_284/elevation.csv create mode 100644 data-raw/logs/habitat_score_284/elevation_adjusted.csv create mode 100644 data-raw/logs/habitat_score_284/stamp_build.txt create mode 100644 data-raw/logs/habitat_score_284/stamp_score.txt create mode 100644 data-raw/logs/habitat_score_284/summary.csv create mode 100644 data-raw/logs/habitat_score_284/taper.csv create mode 100644 data-raw/logs/habitat_score_284/totals.csv create mode 100644 data-raw/logs/habitat_score_284/verdict.csv diff --git a/CLAUDE.md b/CLAUDE.md index d3de400e..6b6668dc 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -11,6 +11,36 @@ Experimental package — breaking all the time and loving the learning curve. St **Prefix:** `lnk_` **Branch:** `main` (v0.49.0 as of 2026-09-01) +## Status (2026-09-29) — #284 step 5: BT `rear_gradient_max` 0.1349 scored and held + +**Threshold variants are scored on one shared segmentation, never on two full runs.** +- `data-raw/habitat_variants_build.R` models a closure once under `default` into + `score284_default`, keeps the focal working schemas, and re-classifies each variant + (a thin bundle, one cell changed) into `score284_`. +- `data-raw/habitat_variants_score.R` scores each ladder step with the new + `lnk_habitat_validate_band()`: locations per km on the segments the step moves, + against the core every step agrees on. Held-out WSGs decide. +- Inputs are data (`data-raw/habitat_score/`). Method and results: + `research/habitat_thresholds.md`, "Step 5". + +**Facts not worth re-deriving:** +- **Power first.** A counts-only check before the build showed the planned held-out set + could decide one step in six (`data-raw/logs/habitat_score_284/power_windows.*`). + BT was widened to eight held-out WSGs, and CH dropped: unscorable, spread thin. +- **Result.** Steps to 0.1349 take (ratio 0.60 and 0.71; 0.75 and 0.89 + elevation-adjusted). 0.1449 does not (8 found, 25 expected). +- **Elevation confounds gradient.** Core BT rearing thins 24.6 → 10.2 per 100 km from + the low to the high third, and steep bands sit high. Weights instead of cutoffs went + to knowledge#28, the biology first. +- **The n ≥ 10 floor on locations *found* cannot refuse a band fish avoid.** A floor on + locations *expected* at the core rate can. Both readings are in `verdict.csv`; they + agreed here, and the choice is open. +- **Resume trusts nothing it cannot prove.** A base WSG is reused only when its log row + is clean at this HEAD and its digest sits in the same `--out`; `built.csv` is per + variant × WSG. Code-check took five rounds to get there (`planning/archive/…-284-*`). +- Loosening a rearing cutoff can **remove** a little rearing (1.1 km against 1,365 km): + clusters merge. + ## Status (2026-09-26, late) — observation validation (#283) **`lnk_habitat_validate()` scores a run against fish, not against bcfishpass.** diff --git a/data-raw/logs/habitat_score_284/bands.csv b/data-raw/logs/habitat_score_284/bands.csv new file mode 100644 index 00000000..ada2f162 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bands.csv @@ -0,0 +1,217 @@ +"variant","step_from","column","value_from","value","step_direction","obs_stage","watershed_group_code","species_code","direction","flag","stage","band_km","n_band","core_km","n_core","density_band","density_core","density_ratio","n_absence_band","role" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","added","rearing","any",32.0286538872878,3,2055.07648874055,105,0.0936661281662763,0.0510929887891176,1.83324816938927,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","removed","rearing","any",0,0,2055.07648874055,105,,0.0510929887891176,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","added","rearing","any",60.6227270502256,6,1723.88438335523,263,0.0989727828480733,0.152562435473844,0.64873625372244,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","removed","rearing","any",0,0,1723.88438335523,263,,0.152562435473844,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","added","rearing","any",121.221395718044,21,3009.80851308213,338,0.173236744846967,0.112299502952059,1.54263144798532,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","removed","rearing","any",0.514999999999958,1,3009.80851308213,338,1.94174757281569,0.112299502952059,17.2907940086309,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","added","rearing","any",59.1684332520501,1,1062.04039165997,64,0.0169009038272169,0.060261361528791,0.280460039376013,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","removed","rearing","any",0,0,1062.04039165997,64,,0.060261361528791,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","added","rearing","any",44.9574271066544,1,988.113654830613,75,0.0222432657818175,0.0759021997452883,0.293051661960538,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830613,75,,0.0759021997452883,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","added","rearing","any",120.379656339594,5,2122.70865932044,563,0.0415352573020717,0.265227165078904,0.156602576096288,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078904,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","added","rearing","any",107.717519598346,3,1599.0204217732,164,0.0278506227323682,0.102562792674115,0.271547039683888,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","removed","rearing","any",0.189000000000032,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","added","rearing","any",35.2917856495189,11,906.052043482134,368,0.311687260861224,0.40615768448102,0.767404564213753,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","removed","rearing","any",0.065013210197991,0,906.052043482134,368,0,0.40615768448102,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","added","rearing","any",49.2376964983885,8,1692.09746836156,259,0.162477137821868,0.153064468709824,1.06149480144794,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","removed","rearing","any",0,0,1692.09746836156,259,,0.153064468709824,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","added","rearing","any",104.756030237642,6,2634.98859228862,259,0.0572759390212556,0.0982926456524222,0.582708285458019,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","removed","rearing","any",0,0,2634.98859228862,259,,0.0982926456524222,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","added","rearing","any",22.535907767111,5,561.144284048331,240,0.221868142684584,0.427697486764971,0.518750166999473,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","removed","rearing","any",0,0,561.144284048331,240,,0.427697486764971,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","added","rearing","any",47.1498697993456,14,776.924742494946,163,0.296925528311731,0.209801530424371,1.41526864799857,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494946,163,,0.209801530424371,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","added","rearing","spawn",32.0286538872878,0,2055.07648874055,1,0,0.000486599893229692,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","removed","rearing","spawn",0,0,2055.07648874055,1,,0.000486599893229692,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","added","rearing","spawn",60.6227270502256,0,1723.88438335523,4,0,0.0023203412239368,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","removed","rearing","spawn",0,0,1723.88438335523,4,,0.0023203412239368,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","added","rearing","spawn",121.221395718044,1,3009.80851308213,9,0.00824936880223654,0.0029902234513862,2.75878004983619,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","removed","rearing","spawn",0.514999999999958,0,3009.80851308213,9,0,0.0029902234513862,0,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","added","rearing","spawn",59.1684332520501,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","removed","rearing","spawn",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","added","rearing","spawn",44.9574271066544,0,988.113654830613,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","removed","rearing","spawn",0,0,988.113654830613,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","added","rearing","spawn",120.379656339594,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","removed","rearing","spawn",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","added","rearing","spawn",107.717519598346,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","removed","rearing","spawn",0.189000000000032,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","added","rearing","spawn",35.2917856495189,0,906.052043482134,6,0,0.00662213616001663,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","removed","rearing","spawn",0.065013210197991,0,906.052043482134,6,0,0.00662213616001663,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","added","rearing","spawn",49.2376964983885,0,1692.09746836156,15,0,0.008864737570067,0,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","removed","rearing","spawn",0,0,1692.09746836156,15,,0.008864737570067,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","added","rearing","spawn",104.756030237642,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","removed","rearing","spawn",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","added","rearing","spawn",22.535907767111,0,561.144284048331,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.144284048331,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","added","rearing","spawn",47.1498697993456,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","removed","rearing","spawn",0,0,776.924742494946,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","added","rearing","rear",32.0286538872878,3,2055.07648874055,85,0.0936661281662763,0.0413609909245238,2.2646006798338,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABL","BT","removed","rearing","rear",0,0,2055.07648874055,85,,0.0413609909245238,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","added","rearing","rear",60.6227270502256,6,1723.88438335523,148,0.0989727828480733,0.0858526252856615,1.15282185627704,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BABR","BT","removed","rearing","rear",0,0,1723.88438335523,148,,0.0858526252856615,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","added","rearing","rear",121.221395718044,17,3009.80851308213,161,0.140239269638021,0.0534917750747975,2.62169781133501,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULK","BT","removed","rearing","rear",0.514999999999958,1,3009.80851308213,161,1.94174757281569,0.0534917750747975,36.299927794517,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","added","rearing","rear",59.1684332520501,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BULL","BT","removed","rearing","rear",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","added","rearing","rear",44.9574271066544,0,988.113654830613,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","CLRH","BT","removed","rearing","rear",0,0,988.113654830613,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","added","rearing","rear",120.379656339594,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","added","rearing","rear",107.717519598346,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","KOTL","BT","removed","rearing","rear",0.189000000000032,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","added","rearing","rear",35.2917856495189,1,906.052043482134,8,0.0283352055328386,0.00882951488002218,3.20914635943933,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","LILL","BT","removed","rearing","rear",0.065013210197991,0,906.052043482134,8,0,0.00882951488002218,0,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","added","rearing","rear",49.2376964983885,5,1692.09746836156,63,0.101548211138668,0.0372318977942814,2.72745192038706,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942814,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","added","rearing","rear",104.756030237642,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","PARS","BT","removed","rearing","rear",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","added","rearing","rear",22.535907767111,0,561.144284048331,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","REVL","BT","removed","rearing","rear",0,0,561.144284048331,0,,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","added","rearing","rear",47.1498697993456,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","UARL","BT","removed","rearing","rear",0,0,776.924742494946,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","any",9.67702491184096,6,2055.07648874055,105,0.620025271678107,0.0510929887891176,12.1352319833395,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","removed","rearing","any",0,0,2055.07648874055,105,,0.0510929887891176,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","added","rearing","any",21.665527749263,3,1723.88438335523,263,0.138468817132879,0.152562435473844,0.907620651851865,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","removed","rearing","any",0,0,1723.88438335523,263,,0.152562435473844,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","added","rearing","any",37.9287874351826,5,3009.80851308213,338,0.131825991235407,0.112299502952059,1.17387867060893,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","removed","rearing","any",0,0,3009.80851308213,338,,0.112299502952059,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","added","rearing","any",29.3769243400633,0,1062.04039165997,64,0,0.060261361528791,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","any",0,0,1062.04039165997,64,,0.060261361528791,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","any",15.1338064085111,2,988.113654830613,75,0.132154459097297,0.0759021997452882,1.74111500774391,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830613,75,,0.0759021997452882,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","any",40.4349169761764,0,2122.70865932044,563,0,0.265227165078903,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078903,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","any",35.4085601703188,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","any",0.298000000000023,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","any",16.2329947693528,3,906.052043482134,368,0.184808782521379,0.40615768448102,0.455017323524295,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","any",0,0,906.052043482134,368,,0.40615768448102,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","any",28.8705363433332,5,1692.09746836156,259,0.173186945352839,0.153064468709824,1.13146406094522,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","any",0,0,1692.09746836156,259,,0.153064468709824,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","any",35.3697425932225,1,2634.98859228862,259,0.0282727531127585,0.0982926456524223,0.28763854024985,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","any",0,0,2634.98859228862,259,,0.0982926456524223,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","any",9.0739434693417,2,561.14428404833,240,0.220411335684142,0.427697486764971,0.515344004827558,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","any",0,0,561.14428404833,240,,0.427697486764971,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","any",21.4460865658432,5,776.924742494946,163,0.233142768712097,0.209801530424371,1.11125389905647,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494946,163,,0.209801530424371,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","spawn",9.67702491184096,0,2055.07648874055,1,0,0.000486599893229692,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","removed","rearing","spawn",0,0,2055.07648874055,1,,0.000486599893229692,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","added","rearing","spawn",21.665527749263,0,1723.88438335523,4,0,0.0023203412239368,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","removed","rearing","spawn",0,0,1723.88438335523,4,,0.0023203412239368,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","added","rearing","spawn",37.9287874351826,0,3009.80851308213,9,0,0.0029902234513862,0,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","removed","rearing","spawn",0,0,3009.80851308213,9,,0.0029902234513862,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","added","rearing","spawn",29.3769243400633,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","spawn",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","spawn",15.1338064085111,0,988.113654830612,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","spawn",0,0,988.113654830612,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","spawn",40.4349169761764,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","spawn",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","spawn",35.4085601703188,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","spawn",0.298000000000023,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","spawn",16.2329947693528,0,906.052043482134,6,0,0.00662213616001663,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","spawn",0,0,906.052043482134,6,,0.00662213616001663,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","spawn",28.8705363433332,1,1692.09746836156,15,0.0346373890705679,0.008864737570067,3.90732255713082,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","spawn",0,0,1692.09746836156,15,,0.008864737570067,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","spawn",35.3697425932226,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","spawn",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","spawn",9.0739434693417,0,561.144284048331,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.144284048331,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","spawn",21.4460865658432,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","spawn",0,0,776.924742494946,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","rear",9.67702491184096,4,2055.07648874055,85,0.413350181118738,0.0413609909245238,9.99372045686783,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","removed","rearing","rear",0,0,2055.07648874055,85,,0.0413609909245238,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","added","rearing","rear",21.665527749263,3,1723.88438335523,148,0.138468817132879,0.0858526252856615,1.61286642862865,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","removed","rearing","rear",0,0,1723.88438335523,148,,0.0858526252856615,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","added","rearing","rear",37.9287874351826,4,3009.80851308213,161,0.105460792988326,0.0534917750747975,1.97153287287363,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","removed","rearing","rear",0,0,3009.80851308213,161,,0.0534917750747975,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","added","rearing","rear",29.3769243400633,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","rear",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","rear",15.1338064085111,0,988.113654830612,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","rear",0,0,988.113654830612,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","rear",40.4349169761764,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","rear",35.4085601703188,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","rear",0.298000000000023,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","rear",16.2329947693528,0,906.052043482134,8,0,0.00882951488002217,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","rear",0,0,906.052043482134,8,,0.00882951488002217,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","rear",28.8705363433332,3,1692.09746836156,63,0.103912167211704,0.0372318977942814,2.79094468366487,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942814,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","rear",35.3697425932225,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","rear",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","rear",9.0739434693417,0,561.14428404833,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","rear",0,0,561.14428404833,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","rear",21.4460865658432,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","rear",0,0,776.924742494946,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","added","rearing","any",7.74047832366764,2,2055.07648874055,105,0.258381965089252,0.0510929887891176,5.05709239590002,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","removed","rearing","any",0,0,2055.07648874055,105,,0.0510929887891176,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","any",12.6344733026478,0,1723.88438335523,263,0,0.152562435473844,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","any",0,0,1723.88438335523,263,,0.152562435473844,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","any",44.725705986597,4,3009.80851308213,338,0.0894340270715611,0.112299502952059,0.796388449820126,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","any",0,0,3009.80851308213,338,,0.112299502952059,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","added","rearing","any",17.6929224260818,0,1062.04039165997,64,0,0.060261361528791,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","any",0,0,1062.04039165997,64,,0.060261361528791,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","any",15.5179615510741,0,988.113654830612,75,0,0.0759021997452883,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830612,75,,0.0759021997452883,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","any",47.2946196566879,2,2122.70865932044,563,0.0422881083412452,0.265227165078904,0.15944109016384,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078904,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","added","rearing","any",36.823799566551,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","removed","rearing","any",0,0,1599.0204217732,164,,0.102562792674115,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","added","rearing","any",10.0037762114398,1,906.052043482134,368,0.0999622521399922,0.40615768448102,0.246116855495968,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","removed","rearing","any",0,0,906.052043482134,368,,0.40615768448102,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","added","rearing","any",16.4592075009036,5,1692.09746836156,259,0.303781333319086,0.153064468709824,1.98466264496033,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","removed","rearing","any",0,0,1692.09746836156,259,,0.153064468709824,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","any",23.7460202217577,0,2634.98859228862,259,0,0.0982926456524222,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","removed","rearing","any",0,0,2634.98859228862,259,,0.0982926456524222,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","any",11.9599072358722,0,561.14428404833,240,0,0.427697486764971,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","any",0,0,561.14428404833,240,,0.427697486764971,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","added","rearing","any",14.6654583060648,3,776.924742494946,163,0.20456230807048,0.209801530424371,0.975027720992819,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494946,163,,0.209801530424371,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","added","rearing","spawn",7.74047832366764,0,2055.07648874055,1,0,0.000486599893229692,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","removed","rearing","spawn",0,0,2055.07648874055,1,,0.000486599893229692,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","spawn",12.6344733026478,0,1723.88438335523,4,0,0.0023203412239368,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","spawn",0,0,1723.88438335523,4,,0.0023203412239368,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","spawn",44.725705986597,0,3009.80851308213,9,0,0.00299022345138619,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","spawn",0,0,3009.80851308213,9,,0.00299022345138619,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","added","rearing","spawn",17.6929224260818,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","spawn",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","spawn",15.5179615510741,0,988.113654830612,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","spawn",0,0,988.113654830612,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","spawn",47.2946196566879,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","spawn",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","added","rearing","spawn",36.823799566551,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","removed","rearing","spawn",0,0,1599.0204217732,0,,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","added","rearing","spawn",10.0037762114398,0,906.052043482134,6,0,0.00662213616001663,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","removed","rearing","spawn",0,0,906.052043482134,6,,0.00662213616001663,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","added","rearing","spawn",16.4592075009036,0,1692.09746836156,15,0,0.008864737570067,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","removed","rearing","spawn",0,0,1692.09746836156,15,,0.008864737570067,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","spawn",23.7460202217577,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","removed","rearing","spawn",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","spawn",11.9599072358722,0,561.14428404833,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.14428404833,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","added","rearing","spawn",14.6654583060648,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","removed","rearing","spawn",0,0,776.924742494946,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","added","rearing","rear",7.74047832366764,2,2055.07648874055,85,0.258381965089252,0.0413609909245238,6.24699648905296,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","removed","rearing","rear",0,0,2055.07648874055,85,,0.0413609909245238,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","rear",12.6344733026478,0,1723.88438335523,148,0,0.0858526252856615,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","rear",0,0,1723.88438335523,148,,0.0858526252856615,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","rear",44.725705986597,0,3009.80851308213,161,0,0.0534917750747975,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","rear",0,0,3009.80851308213,161,,0.0534917750747975,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","added","rearing","rear",17.6929224260818,0,1062.04039165997,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","rear",0,0,1062.04039165997,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","rear",15.5179615510741,0,988.113654830613,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","rear",0,0,988.113654830613,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","rear",47.2946196566879,0,2122.70865932043,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932043,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","added","rearing","rear",36.823799566551,0,1599.0204217732,0,0,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","removed","rearing","rear",0,0,1599.0204217732,0,,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","added","rearing","rear",10.0037762114398,0,906.052043482134,8,0,0.00882951488002217,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","removed","rearing","rear",0,0,906.052043482134,8,,0.00882951488002217,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","added","rearing","rear",16.4592075009036,2,1692.09746836156,63,0.121512533327635,0.0372318977942814,3.26366746060143,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942814,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","rear",23.7460202217577,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","removed","rearing","rear",0,0,2634.98859228862,0,,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","rear",11.9599072358722,0,561.14428404833,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","rear",0,0,561.14428404833,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","added","rearing","rear",14.6654583060648,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","removed","rearing","rear",0,0,776.924742494946,0,,0,,,"held_out" diff --git a/data-raw/logs/habitat_score_284/bands_pooled.csv b/data-raw/logs/habitat_score_284/bands_pooled.csv new file mode 100644 index 00000000..add20b8c --- /dev/null +++ b/data-raw/logs/habitat_score_284/bands_pooled.csv @@ -0,0 +1,37 @@ +"variant","step_from","column","value_from","value","step_direction","obs_stage","species_code","flag","role","direction","stage","band_km","n_band","core_km","n_core","density_band","density_core","density_ratio" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","added","any",422.134460851787,46,10195.9446479322,1841,0.108970018479848,0.180561984550727,0.603504767357241 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","added","rear",422.134460851787,10,10195.9446479322,241,0.0236891344521409,0.0236368486022407,1.00221204826329 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","added","spawn",422.134460851787,0,10195.9446479322,11,0,0.00107886030964584,0 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","removed","any",0.065013210197991,0,10195.9446479322,1841,0,0.180561984550727,0 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","removed","rear",0.065013210197991,0,10195.9446479322,241,0,0.0236368486022407,0 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","removed","spawn",0.065013210197991,0,10195.9446479322,11,0,0.00107886030964584,0 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","added","any",382.93264205242,38,8935.91499550551,1020,0.0992341624269214,0.114146117159018,0.869360823624663 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","added","rear",382.93264205242,22,8935.91499550551,224,0.0574513571945334,0.0250673825917844,2.29187698333382 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","added","spawn",382.93264205242,1,8935.91499550551,24,0.00261142532702425,0.0026857909919769,0.972311447474952 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","removed","any",0.70399999999999,1,8935.91499550551,1020,1.42045454545457,0.114146117159018,12.4441775227073 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","removed","rear",0.70399999999999,1,8935.91499550551,224,1.42045454545457,0.0250673825917844,56.6654512194706 +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","in_sample","removed","spawn",0.70399999999999,0,8935.91499550551,24,0,0.0026857909919769,0 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","added","any",163.041225190392,21,10195.9446479322,1841,0.128801779890191,0.180561984550727,0.713338304353903 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","added","rear",163.041225190392,7,10195.9446479322,241,0.0429339266300637,0.0236368486022407,1.81639808895648 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","added","spawn",163.041225190392,0,10195.9446479322,11,0,0.00107886030964584,0 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","removed","any",0,0,10195.9446479322,1841,,0.180561984550727, +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","removed","rear",0,0,10195.9446479322,241,,0.0236368486022407, +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","removed","spawn",0,0,10195.9446479322,11,,0.00107886030964584, +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","any",137.577626542057,11,8935.91499550551,1020,0.0799548609499912,0.114146117159018,0.700460628359396 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","rear",137.577626542057,7,8935.91499550551,224,0.0508803660590853,0.0250673825917844,2.02974386626871 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","spawn",137.577626542057,1,8935.91499550551,24,0.00726862372272647,0.0026857909919769,2.70632515502494 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","removed","any",0.298000000000023,0,8935.91499550551,1020,0,0.114146117159018,0 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","removed","rear",0.298000000000023,0,8935.91499550551,224,0,0.0250673825917844,0 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","removed","spawn",0.298000000000023,0,8935.91499550551,24,0,0.0026857909919769,0 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","added","any",137.509597013536,8,10195.9446479322,1841,0.0581777575801674,0.180561984550727,0.322203800123957 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","added","rear",137.509597013536,2,10195.9446479322,241,0.0145444393950418,0.0236368486022407,0.615329041523033 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","added","spawn",137.509597013536,0,10195.9446479322,11,0,0.00107886030964584,0 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","any",0,0,10195.9446479322,1841,,0.180561984550727, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","rear",0,0,10195.9446479322,241,,0.0236368486022407, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","spawn",0,0,10195.9446479322,11,,0.00107886030964584, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","any",121.754733275809,9,8935.91499550551,1020,0.0739190974991702,0.114146117159018,0.64758310960497 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","rear",121.754733275809,2,8935.91499550551,224,0.0164264661109267,0.0250673825917844,0.655292432338362 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","spawn",121.754733275809,0,8935.91499550552,24,0,0.0026857909919769,0 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","any",0,0,8935.91499550551,1020,,0.114146117159018, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","rear",0,0,8935.91499550551,224,,0.0250673825917844, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","spawn",0,0,8935.91499550552,24,,0.0026857909919769, diff --git a/data-raw/logs/habitat_score_284/base_habitat_digest.csv b/data-raw/logs/habitat_score_284/base_habitat_digest.csv new file mode 100644 index 00000000..a7b07c98 --- /dev/null +++ b/data-raw/logs/habitat_score_284/base_habitat_digest.csv @@ -0,0 +1,13 @@ +"watershed_group_code","digest" +"BABL","877a0abb8d918008a9ffa60f34f06c2e" +"BABR","5a787bf2de7f2ca07d02140602932186" +"BULK","3f261dc91967bfdb96bd8e88f84f11bb" +"BULL","8b004d37121ffc40e2d5ac771455df0e" +"CLRH","c34dac01e4cbf2e2957297a60504af26" +"ELKR","a5366be51cb9db114c9e4ace229966fc" +"KOTL","7deeab8a0ef340e8cd1f96defdcfe856" +"LILL","e90564e8bae84b03097092986187ed78" +"MORR","129f26140aaef44bd400447affed1b39" +"PARS","4fa0d727e25c0cceae7684978ea2a7a4" +"REVL","24b1bee54a8c94aac05a56b3fe6c7a49" +"UARL","5387f29e052129e1083a1adb620c1e97" diff --git a/data-raw/logs/habitat_score_284/base_recompute.csv b/data-raw/logs/habitat_score_284/base_recompute.csv new file mode 100644 index 00000000..0f1d98fa --- /dev/null +++ b/data-raw/logs/habitat_score_284/base_recompute.csv @@ -0,0 +1,13 @@ +"watershed_group_code","access_unchanged" +"BABL",TRUE +"BABR",TRUE +"BULK",TRUE +"BULL",TRUE +"CLRH",TRUE +"ELKR",TRUE +"KOTL",TRUE +"LILL",TRUE +"MORR",TRUE +"PARS",TRUE +"REVL",FALSE +"UARL",TRUE diff --git a/data-raw/logs/habitat_score_284/bridge_band.csv b/data-raw/logs/habitat_score_284/bridge_band.csv new file mode 100644 index 00000000..caf45120 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bridge_band.csv @@ -0,0 +1,110 @@ +"variant","step_from","species_code","watershed_group_code","spawning_upstream","in_window","km","role" +"bt_rear_0p1249","default","BT","BABL",FALSE,FALSE,14.1218176426014,"held_out" +"bt_rear_0p1249","default","BT","BABL",FALSE,TRUE,10.670711929456,"held_out" +"bt_rear_0p1249","default","BT","BABL",TRUE,TRUE,7.23612431523042,"held_out" +"bt_rear_0p1249","default","BT","BABR",FALSE,FALSE,26.5230881513177,"held_out" +"bt_rear_0p1249","default","BT","BABR",FALSE,TRUE,21.8782963685213,"held_out" +"bt_rear_0p1249","default","BT","BABR",TRUE,TRUE,12.2213425303866,"held_out" +"bt_rear_0p1249","default","BT","BULK",FALSE,FALSE,44.8996679483216,"in_sample" +"bt_rear_0p1249","default","BT","BULK",FALSE,TRUE,50.0429114624976,"in_sample" +"bt_rear_0p1249","default","BT","BULK",TRUE,TRUE,26.2788163072244,"in_sample" +"bt_rear_0p1249","default","BT","BULL",FALSE,FALSE,20.7829834590131,"held_out" +"bt_rear_0p1249","default","BT","BULL",FALSE,TRUE,26.3489253442464,"held_out" +"bt_rear_0p1249","default","BT","BULL",TRUE,TRUE,12.0365244487905,"held_out" +"bt_rear_0p1249","default","BT","CLRH",FALSE,FALSE,4.68171528316873,"held_out" +"bt_rear_0p1249","default","BT","CLRH",FALSE,TRUE,18.010825611985,"held_out" +"bt_rear_0p1249","default","BT","CLRH",TRUE,TRUE,22.2648862115008,"held_out" +"bt_rear_0p1249","default","BT","ELKR",FALSE,FALSE,25.3586311668453,"held_out" +"bt_rear_0p1249","default","BT","ELKR",FALSE,TRUE,68.8734998628793,"held_out" +"bt_rear_0p1249","default","BT","ELKR",TRUE,TRUE,26.1475253098693,"held_out" +"bt_rear_0p1249","default","BT","KOTL",FALSE,FALSE,20.9367285403728,"in_sample" +"bt_rear_0p1249","default","BT","KOTL",FALSE,TRUE,43.7086195229832,"in_sample" +"bt_rear_0p1249","default","BT","KOTL",TRUE,TRUE,43.0721715349895,"in_sample" +"bt_rear_0p1249","default","BT","LILL",FALSE,FALSE,1.28039900687085,"held_out" +"bt_rear_0p1249","default","BT","LILL",FALSE,TRUE,11.6357846296263,"held_out" +"bt_rear_0p1249","default","BT","LILL",TRUE,FALSE,0.0712501056581846,"held_out" +"bt_rear_0p1249","default","BT","LILL",TRUE,TRUE,22.3043519073635,"held_out" +"bt_rear_0p1249","default","BT","MORR",FALSE,FALSE,17.1813062841651,"in_sample" +"bt_rear_0p1249","default","BT","MORR",FALSE,TRUE,19.7756863435698,"in_sample" +"bt_rear_0p1249","default","BT","MORR",TRUE,TRUE,12.2807038706536,"in_sample" +"bt_rear_0p1249","default","BT","PARS",FALSE,FALSE,27.6108280649582,"in_sample" +"bt_rear_0p1249","default","BT","PARS",FALSE,TRUE,61.6237776992448,"in_sample" +"bt_rear_0p1249","default","BT","PARS",TRUE,TRUE,15.5214244734391,"in_sample" +"bt_rear_0p1249","default","BT","REVL",FALSE,FALSE,2.12402170138014,"held_out" +"bt_rear_0p1249","default","BT","REVL",FALSE,TRUE,8.18053250365036,"held_out" +"bt_rear_0p1249","default","BT","REVL",TRUE,TRUE,12.2313535620805,"held_out" +"bt_rear_0p1249","default","BT","UARL",FALSE,FALSE,6.2576139260766,"held_out" +"bt_rear_0p1249","default","BT","UARL",FALSE,TRUE,15.2197255362419,"held_out" +"bt_rear_0p1249","default","BT","UARL",TRUE,TRUE,25.6725303370271,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABL",FALSE,FALSE,3.33478393489574,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABL",FALSE,TRUE,3.44014101780547,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABL",TRUE,TRUE,2.90209995913975,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABR",FALSE,FALSE,10.9482537258837,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABR",FALSE,TRUE,6.8105301609447,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BABR",TRUE,TRUE,3.90674386243452,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULK",FALSE,FALSE,14.6056331680102,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULK",FALSE,TRUE,14.8010465145284,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULK",TRUE,TRUE,8.52210775264401,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULL",FALSE,FALSE,12.8705038965318,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULL",FALSE,TRUE,12.2220200256773,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","BULL",TRUE,TRUE,4.28440041785419,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",FALSE,FALSE,2.43601931213392,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",FALSE,TRUE,4.68317506763157,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",TRUE,TRUE,8.01461202874563,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","ELKR",FALSE,FALSE,16.7025648404777,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","ELKR",FALSE,TRUE,16.926783235467,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","ELKR",TRUE,TRUE,6.80556890023166,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","KOTL",FALSE,FALSE,11.3183389261455,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","KOTL",FALSE,TRUE,12.4735628503874,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","KOTL",TRUE,TRUE,11.6166583937859,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","LILL",FALSE,FALSE,4.05601684304963,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","LILL",FALSE,TRUE,4.70075485752868,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","LILL",TRUE,TRUE,7.4762230687745,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","MORR",FALSE,FALSE,13.9968743265805,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","MORR",FALSE,TRUE,11.414724006598,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","MORR",TRUE,TRUE,3.45893801015461,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","PARS",FALSE,FALSE,14.7751100714056,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","PARS",FALSE,TRUE,15.1916215197573,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","PARS",TRUE,TRUE,5.40301100205964,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","REVL",FALSE,FALSE,0.43923962060241,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","REVL",FALSE,TRUE,2.25315537964721,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","REVL",TRUE,TRUE,6.38154846909208,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","UARL",FALSE,FALSE,7.9228866970992,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","UARL",FALSE,TRUE,4.61383758918555,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","UARL",TRUE,TRUE,8.90936227955849,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABL",FALSE,FALSE,3.39815701172267,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABL",FALSE,TRUE,3.24123103944117,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABL",TRUE,TRUE,1.1010902725038,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABR",FALSE,FALSE,5.76995585015026,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABR",FALSE,TRUE,4.50432632224241,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABR",TRUE,TRUE,2.36019113025511,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULK",FALSE,FALSE,28.0480140963787,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULK",FALSE,TRUE,11.1564472435147,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULK",TRUE,TRUE,5.52124464670368,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULL",FALSE,FALSE,7.95245486227198,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULL",FALSE,TRUE,7.06549218546792,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BULL",TRUE,TRUE,2.67497537834193,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",FALSE,FALSE,3.35575956871938,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",FALSE,TRUE,6.29262864947983,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",TRUE,TRUE,5.86957333287492,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",FALSE,FALSE,21.9839821420258,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",FALSE,TRUE,15.8237144901717,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",TRUE,TRUE,9.4869230244904,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","KOTL",FALSE,FALSE,15.5496678660605,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","KOTL",FALSE,TRUE,11.0902250168126,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","KOTL",TRUE,TRUE,10.1839066836779,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","LILL",FALSE,FALSE,1.77758799518434,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","LILL",FALSE,TRUE,3.87514165409242,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","LILL",TRUE,TRUE,4.35104656216301,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","MORR",FALSE,FALSE,6.56156733868221,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","MORR",FALSE,TRUE,7.1963921943874,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","MORR",TRUE,TRUE,2.70124796783397,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","PARS",FALSE,FALSE,5.34608698313147,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","PARS",FALSE,TRUE,12.5680183689373,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","PARS",TRUE,TRUE,5.83191486968893,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","REVL",FALSE,FALSE,5.68660358409017,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","REVL",FALSE,TRUE,3.01665467418154,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","REVL",TRUE,TRUE,3.25664897760048,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","UARL",FALSE,FALSE,2.91056204099198,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","UARL",FALSE,TRUE,5.02781483400617,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","UARL",TRUE,TRUE,6.72708143106661,"held_out" diff --git a/data-raw/logs/habitat_score_284/build_20260930_014921-53610765.log b/data-raw/logs/habitat_score_284/build_20260930_014921-53610765.log new file mode 100644 index 00000000..78a35189 --- /dev/null +++ b/data-raw/logs/habitat_score_284/build_20260930_014921-53610765.log @@ -0,0 +1,20988 @@ +18:49:26 base: default, 23 WSGs (focal ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR) into score284_default +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: schema "working_score_larl" does not exist, skipping + +NOTICE: schema "working_score_larl" does not exist, skipping + +NOTICE: schema "working_score_larl" does not exist, skipping + +NOTICE: schema "working_score_larl" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +18:52:33 base LARL done in 3.1 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_lfra" does not exist, skipping + +NOTICE: schema "working_score_lfra" does not exist, skipping + +NOTICE: schema "working_score_lfra" does not exist, skipping + +NOTICE: schema "working_score_lfra" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +18:56:36 base LFRA done in 4.0 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_lpce" does not exist, skipping + +NOTICE: schema "working_score_lpce" does not exist, skipping + +NOTICE: schema "working_score_lpce" does not exist, skipping + +NOTICE: schema "working_score_lpce" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +18:57:51 base LPCE done in 1.2 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_lske" does not exist, skipping + +NOTICE: schema "working_score_lske" does not exist, skipping + +NOTICE: schema "working_score_lske" does not exist, skipping + +NOTICE: schema "working_score_lske" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:02:53 base LSKE done in 5.0 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_harr" does not exist, skipping + +NOTICE: schema "working_score_harr" does not exist, skipping + +NOTICE: schema "working_score_harr" does not exist, skipping + +NOTICE: schema "working_score_harr" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:05:43 base HARR done in 2.8 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_klum" does not exist, skipping + +NOTICE: schema "working_score_klum" does not exist, skipping + +NOTICE: schema "working_score_klum" does not exist, skipping + +NOTICE: schema "working_score_klum" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:09:23 base KLUM done in 3.7 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_kotl" does not exist, skipping + +NOTICE: schema "working_score_kotl" does not exist, skipping + +NOTICE: schema "working_score_kotl" does not exist, skipping + +NOTICE: schema "working_score_kotl" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ko" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_ko" does not exist, skipping + +NOTICE: table "frs_qual_spawn_ko" does not exist, skipping + +NOTICE: table "frs_trace_lfid_ko" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:13:47 base KOTL done in 4.4 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_uarl" does not exist, skipping + +NOTICE: schema "working_score_uarl" does not exist, skipping + +NOTICE: schema "working_score_uarl" does not exist, skipping + +NOTICE: schema "working_score_uarl" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:15:59 base UARL done in 2.2 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_upce" does not exist, skipping + +NOTICE: schema "working_score_upce" does not exist, skipping + +NOTICE: schema "working_score_upce" does not exist, skipping + +NOTICE: schema "working_score_upce" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:17:43 base UPCE done in 1.7 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_bull" does not exist, skipping + +NOTICE: schema "working_score_bull" does not exist, skipping + +NOTICE: schema "working_score_bull" does not exist, skipping + +NOTICE: schema "working_score_bull" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:19:44 base BULL done in 2.0 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_kisp" does not exist, skipping + +NOTICE: schema "working_score_kisp" does not exist, skipping + +NOTICE: schema "working_score_kisp" does not exist, skipping + +NOTICE: schema "working_score_kisp" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:24:12 base KISP done in 4.4 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_lill" does not exist, skipping + +NOTICE: schema "working_score_lill" does not exist, skipping + +NOTICE: schema "working_score_lill" does not exist, skipping + +NOTICE: schema "working_score_lill" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:29:12 base LILL done in 5.0 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_pcea" does not exist, skipping + +NOTICE: schema "working_score_pcea" does not exist, skipping + +NOTICE: schema "working_score_pcea" does not exist, skipping + +NOTICE: schema "working_score_pcea" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_gr" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:32:56 base PCEA done in 3.7 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_revl" does not exist, skipping + +NOTICE: schema "working_score_revl" does not exist, skipping + +NOTICE: schema "working_score_revl" does not exist, skipping + +NOTICE: schema "working_score_revl" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:35:15 base REVL done in 2.3 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_bulk" does not exist, skipping + +NOTICE: schema "working_score_bulk" does not exist, skipping + +NOTICE: schema "working_score_bulk" does not exist, skipping + +NOTICE: schema "working_score_bulk" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +Override validation: working_score_bulk.pscis_fixes vs working_score_bulk.crossings + Total overrides: 589 + Valid (matched): 521 + Orphans: 68 <-- not found in crossings + Duplicates: 0 +Updated 521 of 5568 rows (barrier_status) +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:41:25 base BULK done in 6.1 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_clrh" does not exist, skipping + +NOTICE: schema "working_score_clrh" does not exist, skipping + +NOTICE: schema "working_score_clrh" does not exist, skipping + +NOTICE: schema "working_score_clrh" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:44:06 base CLRH done in 2.7 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_elkr" does not exist, skipping + +NOTICE: schema "working_score_elkr" does not exist, skipping + +NOTICE: schema "working_score_elkr" does not exist, skipping + +NOTICE: schema "working_score_elkr" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +Override validation: working_score_elkr.pscis_fixes vs working_score_elkr.crossings + Total overrides: 329 + Valid (matched): 293 + Orphans: 36 <-- not found in crossings + Duplicates: 0 +Updated 293 of 7306 rows (barrier_status) +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:48:17 base ELKR done in 4.2 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_mske" does not exist, skipping + +NOTICE: schema "working_score_mske" does not exist, skipping + +NOTICE: schema "working_score_mske" does not exist, skipping + +NOTICE: schema "working_score_mske" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:52:13 base MSKE done in 3.9 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_para" does not exist, skipping + +NOTICE: schema "working_score_para" does not exist, skipping + +NOTICE: schema "working_score_para" does not exist, skipping + +NOTICE: schema "working_score_para" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:53:44 base PARA done in 1.5 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_babr" does not exist, skipping + +NOTICE: schema "working_score_babr" does not exist, skipping + +NOTICE: schema "working_score_babr" does not exist, skipping + +NOTICE: schema "working_score_babr" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +19:56:56 base BABR done in 3.2 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_morr" does not exist, skipping + +NOTICE: schema "working_score_morr" does not exist, skipping + +NOTICE: schema "working_score_morr" does not exist, skipping + +NOTICE: schema "working_score_morr" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +Override validation: working_score_morr.pscis_fixes vs working_score_morr.crossings + Total overrides: 1 + Valid (matched): 1 + Orphans: 0 + Duplicates: 0 +Updated 1 of 1599 rows (barrier_status) +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +20:00:27 base MORR done in 3.5 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_pars" does not exist, skipping + +NOTICE: schema "working_score_pars" does not exist, skipping + +NOTICE: schema "working_score_pars" does not exist, skipping + +NOTICE: schema "working_score_pars" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +Override validation: working_score_pars.pscis_fixes vs working_score_pars.crossings + Total overrides: 3 + Valid (matched): 3 + Orphans: 0 + Duplicates: 0 +Updated 3 of 3961 rows (barrier_status) +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "barriers_definite_control" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ko" does not exist, skipping + +NOTICE: table "frs_qual_spawn_ko" does not exist, skipping + +NOTICE: table "frs_trace_lfid_ko" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +20:05:17 base PARS done in 4.8 min +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: schema "working_score_babl" does not exist, skipping + +NOTICE: schema "working_score_babl" does not exist, skipping + +NOTICE: schema "working_score_babl" does not exist, skipping + +NOTICE: schema "working_score_babl" does not exist, skipping + +NOTICE: schema "fresh" already exists, skipping + +NOTICE: table "barriers_definite" does not exist, skipping + +NOTICE: table "observations" does not exist, skipping + +NOTICE: table "streams_blk" does not exist, skipping + +NOTICE: table "gradient_barriers_raw" does not exist, skipping + +NOTICE: table "natural_barriers" does not exist, skipping + +NOTICE: table "barrier_overrides" does not exist, skipping + +NOTICE: table "barriers_bt" does not exist, skipping + +NOTICE: table "barriers_ch" does not exist, skipping + +NOTICE: table "barriers_cm" does not exist, skipping + +NOTICE: table "barriers_co" does not exist, skipping + +NOTICE: table "barriers_pk" does not exist, skipping + +NOTICE: table "barriers_sk" does not exist, skipping + +NOTICE: table "barriers_st" does not exist, skipping + +NOTICE: table "barriers_wct" does not exist, skipping + +NOTICE: table "barriers_ko" does not exist, skipping + +NOTICE: table "barriers_rb" does not exist, skipping + +NOTICE: table "barriers_gr" does not exist, skipping + +NOTICE: table "gradient_barriers_minimal" does not exist, skipping + +NOTICE: table "streams" does not exist, skipping + +NOTICE: table "streams_habitat" does not exist, skipping + +NOTICE: table "cabd_exclusions" does not exist, skipping + +NOTICE: table "cabd_blkey_xref" does not exist, skipping + +NOTICE: table "cabd_passability_status_updates" does not exist, skipping + +NOTICE: table "cabd_additions" does not exist, skipping + +NOTICE: table "cabd_dams_raw" does not exist, skipping + +NOTICE: table "dams" does not exist, skipping + +NOTICE: table "pscis_modelledcrossings_streams_xref" does not exist, skipping + +NOTICE: table "pscis_stream_candidates" does not exist, skipping + +NOTICE: table "pscis_streams_150m" does not exist, skipping + +NOTICE: table "pscis_picked" does not exist, skipping + +NOTICE: table "pscis" does not exist, skipping + +NOTICE: table "crossings_lookup" does not exist, skipping + +NOTICE: table "barriers_anthropogenic" does not exist, skipping + +NOTICE: table "barriers_pscis" does not exist, skipping + +NOTICE: table "barriers_dams" does not exist, skipping + +NOTICE: table "barriers_remediations" does not exist, skipping + +NOTICE: table "observations_breaks" does not exist, skipping + +NOTICE: table "habitat_endpoints" does not exist, skipping + +NOTICE: table "crossings_breaks" does not exist, skipping + +NOTICE: table "streams_breaks" does not exist, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: table "barriers" does not exist, skipping + +20:08:41 base BABL done in 3.4 min +NOTICE: table "zz_lnk_streams_elkr" does not exist, skipping + +20:09:37 recompute ELKR: streams_access unchanged +NOTICE: table "zz_lnk_streams_bull" does not exist, skipping + +20:10:13 recompute BULL: streams_access unchanged +NOTICE: table "zz_lnk_streams_uarl" does not exist, skipping + +20:10:52 recompute UARL: streams_access unchanged +NOTICE: table "zz_lnk_streams_revl" does not exist, skipping + +20:11:29 recompute REVL: streams_access CHANGED +NOTICE: table "zz_lnk_streams_clrh" does not exist, skipping + +20:12:22 recompute CLRH: streams_access unchanged +NOTICE: table "zz_lnk_streams_lill" does not exist, skipping + +20:14:23 recompute LILL: streams_access unchanged +NOTICE: table "zz_lnk_streams_babl" does not exist, skipping + +20:15:02 recompute BABL: streams_access unchanged +NOTICE: table "zz_lnk_streams_babr" does not exist, skipping + +20:15:43 recompute BABR: streams_access unchanged +NOTICE: table "zz_lnk_streams_pars" does not exist, skipping + +20:16:54 recompute PARS: streams_access unchanged +NOTICE: table "zz_lnk_streams_kotl" does not exist, skipping + +20:17:54 recompute KOTL: streams_access unchanged +NOTICE: table "zz_lnk_streams_bulk" does not exist, skipping + +20:19:15 recompute BULK: streams_access unchanged +NOTICE: table "zz_lnk_streams_morr" does not exist, skipping + +20:20:12 recompute MORR: streams_access unchanged +There were 50 or more warnings (use warnings() to see the first 50) +20:20:12 variant default into score284_default (ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR) +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "streams" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_geom_idx" already exists, skipping + +NOTICE: relation "streams_wbk_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_habitat_bt" already exists, skipping + +NOTICE: relation "streams_habitat_bt_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ch" already exists, skipping + +NOTICE: relation "streams_habitat_ch_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_cm" already exists, skipping + +NOTICE: relation "streams_habitat_cm_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_co" already exists, skipping + +NOTICE: relation "streams_habitat_co_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_pk" already exists, skipping + +NOTICE: relation "streams_habitat_pk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_sk" already exists, skipping + +NOTICE: relation "streams_habitat_sk_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_st" already exists, skipping + +NOTICE: relation "streams_habitat_st_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_wct" already exists, skipping + +NOTICE: relation "streams_habitat_wct_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_ko" already exists, skipping + +NOTICE: relation "streams_habitat_ko_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_rb" already exists, skipping + +NOTICE: relation "streams_habitat_rb_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_gr" already exists, skipping + +NOTICE: relation "streams_habitat_gr_wsg_idx" already exists, skipping + +NOTICE: relation "barriers" already exists, skipping + +NOTICE: relation "barriers_wsg_idx" already exists, skipping + +NOTICE: relation "barriers_blocks_idx" already exists, skipping + +NOTICE: relation "barriers_source_idx" already exists, skipping + +NOTICE: relation "barriers_blk_drm_idx" already exists, skipping + +NOTICE: relation "barriers_geom_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_wscode_btree_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_gist_idx" already exists, skipping + +NOTICE: relation "barriers_localcode_btree_idx" already exists, skipping + +NOTICE: relation "barrier_overrides" already exists, skipping + +NOTICE: relation "barrier_overrides_wsg_idx" already exists, skipping + +NOTICE: relation "barrier_overrides_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_access" already exists, skipping + +NOTICE: relation "streams_access_wsg_idx" already exists, skipping + +NOTICE: relation "streams_mapping_code" already exists, skipping + +NOTICE: relation "streams_mapping_code_wsg_idx" already exists, skipping + +NOTICE: schema "score284_default" already exists, skipping + +NOTICE: relation "log" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: relation "log_recompute" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: relation "log_input" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: relation "log_dimensions" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "log_wsg_date_idx" already exists, skipping + +NOTICE: relation "log_config_idx" already exists, skipping + +NOTICE: relation "log_input_rn_idx" already exists, skipping + +NOTICE: relation "log_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_run_uid_idx" already exists, skipping + +NOTICE: relation "log_rc_wsg_date_idx" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +20:22:13 variant default ELKR done in 2.0 min (habitat a5366be5) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +20:22:52 variant default BULL done in 0.6 min (habitat 8b004d37) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +20:23:24 variant default UARL done in 0.5 min (habitat 5387f29e) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +20:23:57 variant default REVL done in 0.5 min (habitat 24b1bee5) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +20:24:37 variant default CLRH done in 0.7 min (habitat c34dac01) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_cm" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +20:25:58 variant default LILL done in 1.4 min (habitat e90564e8) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +20:27:52 variant default BABL done in 1.9 min (habitat 877a0abb) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +20:29:22 variant default BABR done in 1.5 min (habitat 5a787bf2) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ko" does not exist, skipping + +NOTICE: table "frs_qual_spawn_ko" does not exist, skipping + +NOTICE: table "frs_trace_lfid_ko" does not exist, skipping + +NOTICE: table "frs_clusters_gr" does not exist, skipping + +20:31:23 variant default PARS done in 2.0 min (habitat 4fa0d727) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_wct" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ko" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_wct" does not exist, skipping + +NOTICE: table "frs_clusters_ko" does not exist, skipping + +NOTICE: table "frs_qual_spawn_ko" does not exist, skipping + +NOTICE: table "frs_trace_lfid_ko" does not exist, skipping + +20:33:09 variant default KOTL done in 1.8 min (habitat 7deeab8a) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_ch" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_co" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_pk" does not exist, skipping + +NOTICE: table "streams_acc_015_ovr_sk" does not exist, skipping + +NOTICE: table "streams_acc_02_ovr_st" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +20:36:33 variant default BULK done in 3.4 min (habitat 3f261dc9) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_015" does not exist, skipping + +NOTICE: table "streams_acc_02" does not exist, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +NOTICE: table "frs_clusters_ch" does not exist, skipping + +NOTICE: table "frs_clusters_co" does not exist, skipping + +NOTICE: table "frs_clusters_sk" does not exist, skipping + +NOTICE: table "frs_qual_spawn_sk" does not exist, skipping + +NOTICE: table "frs_trace_lfid_sk" does not exist, skipping + +NOTICE: table "frs_clusters_st" does not exist, skipping + +20:38:10 variant default MORR done in 1.6 min (habitat 129f2614) +20:38:10 variant bt_rear_0p1249 into score284_bt_rear_0p1249 (ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR) +NOTICE: schema "score284_bt_rear_0p1249" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:39:19 variant bt_rear_0p1249 ELKR done in 1.1 min (habitat af036f25) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:39:45 variant bt_rear_0p1249 BULL done in 0.4 min (habitat 8b145d6a) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:40:15 variant bt_rear_0p1249 UARL done in 0.5 min (habitat cb181ffb) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:40:40 variant bt_rear_0p1249 REVL done in 0.4 min (habitat f5ccbd3c) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:41:15 variant bt_rear_0p1249 CLRH done in 0.6 min (habitat df90c5eb) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:42:02 variant bt_rear_0p1249 LILL done in 0.8 min (habitat c865d2b6) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:42:44 variant bt_rear_0p1249 BABL done in 0.7 min (habitat 707163f8) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:43:29 variant bt_rear_0p1249 BABR done in 0.7 min (habitat 7e9072a0) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:45:03 variant bt_rear_0p1249 PARS done in 1.6 min (habitat 02dad0c0) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:46:18 variant bt_rear_0p1249 KOTL done in 1.3 min (habitat fe3ab821) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:47:40 variant bt_rear_0p1249 BULK done in 1.4 min (habitat 6122d81c) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:48:29 variant bt_rear_0p1249 MORR done in 0.8 min (habitat b5effe22) +20:48:29 variant bt_rear_0p1349 into score284_bt_rear_0p1349 (ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR) +NOTICE: schema "score284_bt_rear_0p1349" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:49:36 variant bt_rear_0p1349 ELKR done in 1.1 min (habitat 329a1db1) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:50:02 variant bt_rear_0p1349 BULL done in 0.4 min (habitat 22a0fa77) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:50:32 variant bt_rear_0p1349 UARL done in 0.5 min (habitat bcd29819) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:50:56 variant bt_rear_0p1349 REVL done in 0.4 min (habitat 3dbb2463) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:51:29 variant bt_rear_0p1349 CLRH done in 0.6 min (habitat 0f5b8024) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:52:15 variant bt_rear_0p1349 LILL done in 0.8 min (habitat b4fc8bd1) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:52:54 variant bt_rear_0p1349 BABL done in 0.7 min (habitat 56c176b1) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:53:38 variant bt_rear_0p1349 BABR done in 0.7 min (habitat 59dd6a2b) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:55:21 variant bt_rear_0p1349 PARS done in 1.7 min (habitat 681f3236) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:56:37 variant bt_rear_0p1349 KOTL done in 1.3 min (habitat 22d25312) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:58:00 variant bt_rear_0p1349 BULK done in 1.4 min (habitat 82b49612) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:58:48 variant bt_rear_0p1349 MORR done in 0.8 min (habitat f9d963a6) +20:58:49 variant bt_rear_0p1449 into score284_bt_rear_0p1449 (ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR) +NOTICE: schema "score284_bt_rear_0p1449" already exists, skipping + +NOTICE: column "run_id" of relation "log" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log" already exists, skipping + +NOTICE: column "date_start" of relation "log" already exists, skipping + +NOTICE: column "date_end" of relation "log" already exists, skipping + +NOTICE: column "run_uid" of relation "log" already exists, skipping + +NOTICE: column "run_label" of relation "log" already exists, skipping + +NOTICE: column "host" of relation "log" already exists, skipping + +NOTICE: column "config_name" of relation "log" already exists, skipping + +NOTICE: column "config_hash" of relation "log" already exists, skipping + +NOTICE: column "config_drift" of relation "log" already exists, skipping + +NOTICE: column "link_version" of relation "log" already exists, skipping + +NOTICE: column "link_sha" of relation "log" already exists, skipping + +NOTICE: column "link_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_version" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log" already exists, skipping + +NOTICE: column "crate_version" of relation "log" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log" already exists, skipping + +NOTICE: column "arg_dams" of relation "log" already exists, skipping + +NOTICE: column "arg_mapping_code" of relation "log" already exists, skipping + +NOTICE: column "arg_cleanup_working" of relation "log" already exists, skipping + +NOTICE: column "schema_persist" of relation "log" already exists, skipping + +NOTICE: column "species" of relation "log" already exists, skipping + +NOTICE: column "wsg_upstream" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_run_id" of relation "log" already exists, skipping + +NOTICE: column "bcfp_model_version" of relation "log" already exists, skipping + +NOTICE: column "bcfp_pin_source" of relation "log" already exists, skipping + +NOTICE: column "notes" of relation "log" already exists, skipping + +NOTICE: column "recompute_id" of relation "log_recompute" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_start" of relation "log_recompute" already exists, skipping + +NOTICE: column "date_end" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_uid" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_label" of relation "log_recompute" already exists, skipping + +NOTICE: column "host" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_name" of relation "log_recompute" already exists, skipping + +NOTICE: column "config_hash" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "link_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_dirty" of relation "log_recompute" already exists, skipping + +NOTICE: column "fresh_sha_source" of relation "log_recompute" already exists, skipping + +NOTICE: column "crate_version" of relation "log_recompute" already exists, skipping + +NOTICE: column "fwapg_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "bcfishobs_sha" of relation "log_recompute" already exists, skipping + +NOTICE: column "schema_persist" of relation "log_recompute" already exists, skipping + +NOTICE: column "species" of relation "log_recompute" already exists, skipping + +NOTICE: column "views_prebuilt" of relation "log_recompute" already exists, skipping + +NOTICE: column "notes" of relation "log_recompute" already exists, skipping + +NOTICE: column "run_id" of relation "log_input" already exists, skipping + +NOTICE: column "watershed_group_code" of relation "log_input" already exists, skipping + +NOTICE: column "table_name" of relation "log_input" already exists, skipping + +NOTICE: column "row_count" of relation "log_input" already exists, skipping + +NOTICE: column "row_count_estimated" of relation "log_input" already exists, skipping + +NOTICE: column "size_bytes" of relation "log_input" already exists, skipping + +NOTICE: column "last_analyze" of relation "log_input" already exists, skipping + +NOTICE: column "source" of relation "log_input" already exists, skipping + +NOTICE: column "source_at" of relation "log_input" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "access_gradient_max" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "spawn_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "rear_gradient_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_rearing" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawning" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_direction" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_gradient" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_bridge_distance" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "cluster_spawn_confluence_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_threshold" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_date_min" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_buffer_m" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_species" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "observation_control_apply" of relation "log_parameters_fresh" already exists, skipping + +NOTICE: column "config_hash" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "species_code" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_gradient_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_channel_width_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_mad_max" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "spawn_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "rear_edge_types" of relation "log_parameters_habitat_thresholds" already exists, skipping + +NOTICE: column "config_hash" of relation "log_dimensions" already exists, skipping + +NOTICE: column "species" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_no_fw" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_in_waterbody" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_polygon" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_area_only" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_all_edges" of relation "log_dimensions" already exists, skipping + +NOTICE: column "river_skip_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_bypass" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_parent_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_child_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_stream_order_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_direction" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_gradient_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_cw_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_edge_types" of relation "log_dimensions" already exists, skipping + +NOTICE: column "spawn_connected_lake_adjacent" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_requires_connected" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_connected_distance_max" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_lake_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "rear_wetland_ha_min" of relation "log_dimensions" already exists, skipping + +NOTICE: column "notes" of relation "log_dimensions" already exists, skipping + +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +20:59:56 variant bt_rear_0p1449 ELKR done in 1.1 min (habitat 4ace8189) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:00:23 variant bt_rear_0p1449 BULL done in 0.4 min (habitat ae0244a5) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:00:52 variant bt_rear_0p1449 UARL done in 0.5 min (habitat d10ab2ee) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:01:17 variant bt_rear_0p1449 REVL done in 0.4 min (habitat 668cdf34) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:01:50 variant bt_rear_0p1449 CLRH done in 0.6 min (habitat 89695cfe) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:02:19 variant bt_rear_0p1449 LILL done in 0.5 min (habitat b36fd466) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:03:00 variant bt_rear_0p1449 BABL done in 0.7 min (habitat fe2ae53a) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:03:44 variant bt_rear_0p1449 BABR done in 0.7 min (habitat fc5054c0) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:05:21 variant bt_rear_0p1449 PARS done in 1.6 min (habitat 29ed4d86) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:06:41 variant bt_rear_0p1449 KOTL done in 1.3 min (habitat 8d92e00c) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:08:11 variant bt_rear_0p1449 BULK done in 1.5 min (habitat adafd582) +NOTICE: relation "streams_blk_idx" already exists, skipping + +NOTICE: relation "streams_blk_drm_idx" already exists, skipping + +NOTICE: relation "streams_wscode_gist_idx" already exists, skipping + +NOTICE: relation "streams_wscode_btree_idx" already exists, skipping + +NOTICE: relation "streams_localcode_gist_idx" already exists, skipping + +NOTICE: relation "streams_localcode_btree_idx" already exists, skipping + +NOTICE: relation "streams_lfid_idx" already exists, skipping + +NOTICE: relation "streams_wsg_idx" already exists, skipping + +NOTICE: relation "streams_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat" already exists, skipping + +NOTICE: table "streams_acc_025" does not exist, skipping + +NOTICE: table "streams_acc_025_ovr_bt" does not exist, skipping + +NOTICE: relation "streams_habitat_wsg_idx" already exists, skipping + +NOTICE: relation "streams_habitat_id_segment_idx" already exists, skipping + +NOTICE: relation "streams_habitat_species_code_idx" already exists, skipping + +NOTICE: table "frs_clusters_bt" does not exist, skipping + +21:09:01 variant bt_rear_0p1449 MORR done in 0.8 min (habitat ec263205) +21:09:02 build all done in 139.6 min diff --git a/data-raw/logs/habitat_score_284/built.csv b/data-raw/logs/habitat_score_284/built.csv new file mode 100644 index 00000000..0fc7e7a5 --- /dev/null +++ b/data-raw/logs/habitat_score_284/built.csv @@ -0,0 +1,49 @@ +"variant","watershed_group_code","schema","thresholds_sha256","link_head","dirty","built_at" +"default","ELKR","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:22:13 PDT" +"default","BULL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:22:52 PDT" +"default","UARL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:23:24 PDT" +"default","REVL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:23:57 PDT" +"default","CLRH","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:24:37 PDT" +"default","LILL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:25:58 PDT" +"default","BABL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:27:52 PDT" +"default","BABR","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:29:22 PDT" +"default","PARS","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:31:23 PDT" +"default","KOTL","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:33:09 PDT" +"default","BULK","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:36:33 PDT" +"default","MORR","score284_default","7b904a18c29c724737ff24a27750bf05d7bfa281aa4fc1f7ac27c00238db042d","a11a001","FALSE","2026-09-29 20:38:10 PDT" +"bt_rear_0p1249","ELKR","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:39:19 PDT" +"bt_rear_0p1249","BULL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:39:45 PDT" +"bt_rear_0p1249","UARL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:40:15 PDT" +"bt_rear_0p1249","REVL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:40:40 PDT" +"bt_rear_0p1249","CLRH","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:41:15 PDT" +"bt_rear_0p1249","LILL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:42:02 PDT" +"bt_rear_0p1249","BABL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:42:44 PDT" +"bt_rear_0p1249","BABR","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:43:29 PDT" +"bt_rear_0p1249","PARS","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:45:03 PDT" +"bt_rear_0p1249","KOTL","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:46:18 PDT" +"bt_rear_0p1249","BULK","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:47:40 PDT" +"bt_rear_0p1249","MORR","score284_bt_rear_0p1249","f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075","a11a001","FALSE","2026-09-29 20:48:29 PDT" +"bt_rear_0p1349","ELKR","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:49:36 PDT" +"bt_rear_0p1349","BULL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:50:02 PDT" +"bt_rear_0p1349","UARL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:50:32 PDT" +"bt_rear_0p1349","REVL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:50:56 PDT" +"bt_rear_0p1349","CLRH","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:51:29 PDT" +"bt_rear_0p1349","LILL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:52:15 PDT" +"bt_rear_0p1349","BABL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:52:54 PDT" +"bt_rear_0p1349","BABR","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:53:38 PDT" +"bt_rear_0p1349","PARS","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:55:21 PDT" +"bt_rear_0p1349","KOTL","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:56:37 PDT" +"bt_rear_0p1349","BULK","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:58:00 PDT" +"bt_rear_0p1349","MORR","score284_bt_rear_0p1349","8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463","a11a001","FALSE","2026-09-29 20:58:48 PDT" +"bt_rear_0p1449","ELKR","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 20:59:56 PDT" +"bt_rear_0p1449","BULL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:00:22 PDT" +"bt_rear_0p1449","UARL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:00:52 PDT" +"bt_rear_0p1449","REVL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:01:17 PDT" +"bt_rear_0p1449","CLRH","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:01:50 PDT" +"bt_rear_0p1449","LILL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:02:19 PDT" +"bt_rear_0p1449","BABL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:03:00 PDT" +"bt_rear_0p1449","BABR","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:03:44 PDT" +"bt_rear_0p1449","PARS","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:05:21 PDT" +"bt_rear_0p1449","KOTL","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:06:41 PDT" +"bt_rear_0p1449","BULK","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:08:11 PDT" +"bt_rear_0p1449","MORR","score284_bt_rear_0p1449","58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30","a11a001","FALSE","2026-09-29 21:09:01 PDT" diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/config.yaml b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/config.yaml new file mode 100644 index 00000000..82b4ca02 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/config.yaml @@ -0,0 +1,13 @@ +name: bt_rear_0p1249 +description: 'link#284 step 5 scoring variant, generated by data-raw/habitat_variants_build.R + from variants.csv: `default` with BT rear_gradient_max 0.1049 -> 0.1249.' +extends: default +files: + parameters_habitat_thresholds: + path: parameters_habitat_thresholds.csv +pipeline: + schema: score284_bt_rear_0p1249 +provenance: + parameters_habitat_thresholds.csv: + source: link (generated from configs/default; variants.csv row bt_rear_0p1249) + checksum: sha256:f695905587ee51f9053973314e595aff080295a14766b56d5a11191b0d5db075 diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/parameters_habitat_thresholds.csv b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/parameters_habitat_thresholds.csv new file mode 100644 index 00000000..dcfb8f06 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1249/parameters_habitat_thresholds.csv @@ -0,0 +1,12 @@ +"species_code","spawn_gradient_max","spawn_channel_width_min","spawn_channel_width_max","spawn_mad_min","spawn_mad_max","rear_gradient_max","rear_channel_width_min","rear_channel_width_max","rear_mad_min","rear_mad_max","rear_lake_ha_min","spawn_edge_types","rear_edge_types" +"BT",0.0549,2,9999,NA,NA,0.1249,1.5,9999,NA,NA,NA,"stream,canal","" +"CH",0.0449,4,9999,0.46,9999,0.0549,1.5,9999,0.28,100,NA,"stream,canal","stream,canal" +"CM",0.0649,2.1,9999,0.02312,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"CO",0.0549,2,9999,0.164,9999,0.0549,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" +"GR",0.0249,4,9999,NA,NA,0.0349,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"KO",0.0249,2,9999,NA,NA,NA,1.5,9999,NA,NA,200,"stream,canal","" +"PK",0.0649,2.1,9999,0.41133,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"RB",0.0549,2,9999,NA,NA,0.0849,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"SK",0.0249,2,9999,0.175,9999,NA,1.5,9999,NA,NA,200,"stream,canal","" +"ST",0.0449,4,9999,0.447,9999,0.0849,1.5,9999,0.02,60,NA,"stream,canal","stream,canal" +"WCT",0.0549,2,9999,0.164,59.15,0.0849,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/config.yaml b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/config.yaml new file mode 100644 index 00000000..dd65249d --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/config.yaml @@ -0,0 +1,13 @@ +name: bt_rear_0p1349 +description: 'link#284 step 5 scoring variant, generated by data-raw/habitat_variants_build.R + from variants.csv: `default` with BT rear_gradient_max 0.1049 -> 0.1349.' +extends: default +files: + parameters_habitat_thresholds: + path: parameters_habitat_thresholds.csv +pipeline: + schema: score284_bt_rear_0p1349 +provenance: + parameters_habitat_thresholds.csv: + source: link (generated from configs/default; variants.csv row bt_rear_0p1349) + checksum: sha256:8ee57893239b74ac96420cc963e9b48e84c903442342d61efc718d7e187ff463 diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/parameters_habitat_thresholds.csv b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/parameters_habitat_thresholds.csv new file mode 100644 index 00000000..18bb0de1 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1349/parameters_habitat_thresholds.csv @@ -0,0 +1,12 @@ +"species_code","spawn_gradient_max","spawn_channel_width_min","spawn_channel_width_max","spawn_mad_min","spawn_mad_max","rear_gradient_max","rear_channel_width_min","rear_channel_width_max","rear_mad_min","rear_mad_max","rear_lake_ha_min","spawn_edge_types","rear_edge_types" +"BT",0.0549,2,9999,NA,NA,0.1349,1.5,9999,NA,NA,NA,"stream,canal","" +"CH",0.0449,4,9999,0.46,9999,0.0549,1.5,9999,0.28,100,NA,"stream,canal","stream,canal" +"CM",0.0649,2.1,9999,0.02312,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"CO",0.0549,2,9999,0.164,9999,0.0549,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" +"GR",0.0249,4,9999,NA,NA,0.0349,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"KO",0.0249,2,9999,NA,NA,NA,1.5,9999,NA,NA,200,"stream,canal","" +"PK",0.0649,2.1,9999,0.41133,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"RB",0.0549,2,9999,NA,NA,0.0849,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"SK",0.0249,2,9999,0.175,9999,NA,1.5,9999,NA,NA,200,"stream,canal","" +"ST",0.0449,4,9999,0.447,9999,0.0849,1.5,9999,0.02,60,NA,"stream,canal","stream,canal" +"WCT",0.0549,2,9999,0.164,59.15,0.0849,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/config.yaml b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/config.yaml new file mode 100644 index 00000000..a2d65586 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/config.yaml @@ -0,0 +1,13 @@ +name: bt_rear_0p1449 +description: 'link#284 step 5 scoring variant, generated by data-raw/habitat_variants_build.R + from variants.csv: `default` with BT rear_gradient_max 0.1049 -> 0.1449.' +extends: default +files: + parameters_habitat_thresholds: + path: parameters_habitat_thresholds.csv +pipeline: + schema: score284_bt_rear_0p1449 +provenance: + parameters_habitat_thresholds.csv: + source: link (generated from configs/default; variants.csv row bt_rear_0p1449) + checksum: sha256:58e5ea82ebcbfefa4c2e84d5bc0c08b7fe5ecda623f2d8b53ab6ecdf7474df30 diff --git a/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/parameters_habitat_thresholds.csv b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/parameters_habitat_thresholds.csv new file mode 100644 index 00000000..c8381958 --- /dev/null +++ b/data-raw/logs/habitat_score_284/bundles/bt_rear_0p1449/parameters_habitat_thresholds.csv @@ -0,0 +1,12 @@ +"species_code","spawn_gradient_max","spawn_channel_width_min","spawn_channel_width_max","spawn_mad_min","spawn_mad_max","rear_gradient_max","rear_channel_width_min","rear_channel_width_max","rear_mad_min","rear_mad_max","rear_lake_ha_min","spawn_edge_types","rear_edge_types" +"BT",0.0549,2,9999,NA,NA,0.1449,1.5,9999,NA,NA,NA,"stream,canal","" +"CH",0.0449,4,9999,0.46,9999,0.0549,1.5,9999,0.28,100,NA,"stream,canal","stream,canal" +"CM",0.0649,2.1,9999,0.02312,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"CO",0.0549,2,9999,0.164,9999,0.0549,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" +"GR",0.0249,4,9999,NA,NA,0.0349,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"KO",0.0249,2,9999,NA,NA,NA,1.5,9999,NA,NA,200,"stream,canal","" +"PK",0.0649,2.1,9999,0.41133,9999,NA,NA,NA,NA,NA,NA,"stream,canal","" +"RB",0.0549,2,9999,NA,NA,0.0849,1.5,9999,NA,NA,NA,"stream,canal","stream,canal" +"SK",0.0249,2,9999,0.175,9999,NA,1.5,9999,NA,NA,200,"stream,canal","" +"ST",0.0449,4,9999,0.447,9999,0.0849,1.5,9999,0.02,60,NA,"stream,canal","stream,canal" +"WCT",0.0549,2,9999,0.164,59.15,0.0849,1.5,9999,0.03,40,NA,"stream,canal","stream,canal" diff --git a/data-raw/logs/habitat_score_284/closure.txt b/data-raw/logs/habitat_score_284/closure.txt new file mode 100644 index 00000000..97a1eb7c --- /dev/null +++ b/data-raw/logs/habitat_score_284/closure.txt @@ -0,0 +1,23 @@ +LARL +LFRA +LPCE +LSKE +HARR +KLUM +KOTL +UARL +UPCE +BULL +KISP +LILL +PCEA +REVL +BULK +CLRH +ELKR +MSKE +PARA +BABR +MORR +PARS +BABL diff --git a/data-raw/logs/habitat_score_284/elevation.csv b/data-raw/logs/habitat_score_284/elevation.csv new file mode 100644 index 00000000..248c771d --- /dev/null +++ b/data-raw/logs/habitat_score_284/elevation.csv @@ -0,0 +1,25 @@ +"species_code","column","role","class","elev_class","km","n","per_100km","core_per_100km","ratio_to_core" +"BT","rear_gradient_max","held_out","bt_rear_0p1249","low",65.6767599048235,7,10.6582602584905,24.5596218503652,0.433974933467144 +"BT","rear_gradient_max","held_out","bt_rear_0p1249","mid",92.9955260896776,19,20.431090396411,19.3492582250811,1.05591078266389 +"BT","rear_gradient_max","held_out","bt_rear_0p1249","high",263.527188067484,20,7.589349754257,10.2319549267572,0.741730178502877 +"BT","rear_gradient_max","held_out","bt_rear_0p1349","low",29.0281747239031,7,24.1145027773169,24.5596218503652,0.981875980185676 +"BT","rear_gradient_max","held_out","bt_rear_0p1349","mid",31.2042545458181,1,3.20469120174517,19.3492582250811,0.165623465482059 +"BT","rear_gradient_max","held_out","bt_rear_0p1349","high",102.808795920671,13,12.6448324616417,10.2319549267572,1.23581784245107 +"BT","rear_gradient_max","held_out","bt_rear_0p1449","low",21.734720671654,3,13.8027998855883,24.5596218503652,0.562011905952171 +"BT","rear_gradient_max","held_out","bt_rear_0p1449","mid",33.2114526741605,0,0,19.3492582250811,0 +"BT","rear_gradient_max","held_out","bt_rear_0p1449","high",82.5634236677215,5,6.05595041712735,10.2319549267572,0.591866408763263 +"BT","rear_gradient_max","held_out","core","low",3403.96120548399,836,24.5596218503652,24.5596218503652,1 +"BT","rear_gradient_max","held_out","core","mid",3400.64715838606,658,19.3492582250811,19.3492582250811,1 +"BT","rear_gradient_max","held_out","core","high",3391.33628406214,347,10.2319549267572,10.2319549267572,1 +"BT","rear_gradient_max","in_sample","bt_rear_0p1249","low",37.5824512554325,5,13.3040816470886,11.089893103126,1.19965824046928 +"BT","rear_gradient_max","in_sample","bt_rear_0p1249","mid",92.5980184139586,9,9.71943045235113,13.3171881527,0.729841040083268 +"BT","rear_gradient_max","in_sample","bt_rear_0p1249","high",253.456172383029,25,9.86363826335207,9.84009128864476,1.00239296303424 +"BT","rear_gradient_max","in_sample","bt_rear_0p1349","low",10.9412369484126,1,9.13973442596074,11.089893103126,0.824149912083865 +"BT","rear_gradient_max","in_sample","bt_rear_0p1349","mid",26.3802312628852,6,22.7443040214795,13.3171881527,1.70789086710232 +"BT","rear_gradient_max","in_sample","bt_rear_0p1349","high",100.256158330759,4,3.98977984654412,9.84009128864476,0.405461669969285 +"BT","rear_gradient_max","in_sample","bt_rear_0p1449","low",11.355259955083,0,0,11.089893103126,0 +"BT","rear_gradient_max","in_sample","bt_rear_0p1449","mid",28.0627691040838,2,7.12688043215577,13.3171881527,0.535164056438658 +"BT","rear_gradient_max","in_sample","bt_rear_0p1449","high",82.3367042166425,7,8.50167621669888,9.84009128864476,0.863983470001912 +"BT","rear_gradient_max","in_sample","core","low",2984.6996442797,331,11.089893103126,11.089893103126,1 +"BT","rear_gradient_max","in_sample","core","mid",2973.6006990313,396,13.3171881527,13.3171881527,1 +"BT","rear_gradient_max","in_sample","core","high",2977.61465219449,293,9.84009128864476,9.84009128864476,1 diff --git a/data-raw/logs/habitat_score_284/elevation_adjusted.csv b/data-raw/logs/habitat_score_284/elevation_adjusted.csv new file mode 100644 index 00000000..befd0643 --- /dev/null +++ b/data-raw/logs/habitat_score_284/elevation_adjusted.csv @@ -0,0 +1,7 @@ +"species_code","column","role","class","km","n","expected","ratio_elevation_adjusted" +"BT","rear_gradient_max","held_out","bt_rear_0p1249",422.199474061985,46,61.0878914598769,0.753013386134194 +"BT","rear_gradient_max","in_sample","bt_rear_0p1249",383.63664205242,39,41.4396247468154,0.941128213353263 +"BT","rear_gradient_max","held_out","bt_rear_0p1349",163.041225190392,21,23.6863513908807,0.886586526284713 +"BT","rear_gradient_max","in_sample","bt_rear_0p1349",137.577626542057,11,14.5917740163694,0.753849394025697 +"BT","rear_gradient_max","held_out","bt_rear_0p1449",137.509597013536,8,20.2119872410841,0.395804722444051 +"BT","rear_gradient_max","in_sample","bt_rear_0p1449",121.754733275809,9,13.0984648120284,0.687103422359485 diff --git a/data-raw/logs/habitat_score_284/stamp_build.txt b/data-raw/logs/habitat_score_284/stamp_build.txt new file mode 100644 index 00000000..ce9b579d --- /dev/null +++ b/data-raw/logs/habitat_score_284/stamp_build.txt @@ -0,0 +1,11 @@ +--- +date: 2026-09-29 21:09 PDT +step: all; focal: ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR; variants: default,bt_rear_0p1249,bt_rear_0p1349,bt_rear_0p1449 +link: 0.53.0 @ a11a001 (at launch) +variants: data-raw/habitat_score/variants.csv (md5 e7dec4a5b954d20a4d9582fdf483787e); roles: data-raw/habitat_score/wsg_roles.csv (md5 3b6cefdc1b026173f4f8685a4fcd4b49) +fresh: 0.34.0 @ no recorded sha +db: docker fwapg localhost:5432 +base run_uid(s) in score284_default.log: 20260930_014921-53610765 +bcfishobs.observations rows: 373050 +thresholds sha256 (12): default=7b904a18c29c, bt_rear_0p1249=f695905587ee, bt_rear_0p1349=8ee57893239b, bt_rear_0p1449=58e5ea82ebcb + diff --git a/data-raw/logs/habitat_score_284/stamp_score.txt b/data-raw/logs/habitat_score_284/stamp_score.txt new file mode 100644 index 00000000..0c5b6570 --- /dev/null +++ b/data-raw/logs/habitat_score_284/stamp_score.txt @@ -0,0 +1,15 @@ +date: 2026-09-29 22:04 PDT +link: 0.53.0 @ 031c5cc (at launch) +fresh: 0.34.0 @ no recorded sha +db: docker fwapg localhost:5432 +variants: data-raw/habitat_score/variants.csv (md5 e7dec4a5b954d20a4d9582fdf483787e): default,bt_rear_0p1249,bt_rear_0p1349,bt_rear_0p1449 +roles: data-raw/habitat_score/wsg_roles.csv (md5 3b6cefdc1b026173f4f8685a4fcd4b49) +built default: thresholds sha256 7b904a18c29c; link a11a001; 12 WSGs, 2026-09-29 20:22:13 PDT to 2026-09-29 20:38:10 PDT +built bt_rear_0p1249: thresholds sha256 f695905587ee; link a11a001; 12 WSGs, 2026-09-29 20:39:19 PDT to 2026-09-29 20:48:29 PDT +built bt_rear_0p1349: thresholds sha256 8ee57893239b; link a11a001; 12 WSGs, 2026-09-29 20:49:36 PDT to 2026-09-29 20:58:48 PDT +built bt_rear_0p1449: thresholds sha256 58e5ea82ebcb; link a11a001; 12 WSGs, 2026-09-29 20:59:56 PDT to 2026-09-29 21:09:01 PDT +focal: ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR; species: BT; buffers: 0,100 m +rule: n_band >= 10 and density_ratio >= 0.5 on held-out WSGs +pooling: default species_pooling.csv (sha256 9c42964e0469): 12 WSG x species pairs pooled (BT<-DV) +bcfishobs.observations rows: 373050 +absences: FISS snapshots COTR,LNTH,PINE,UNTH,UPCE; knowledge @ 5e4e08e diff --git a/data-raw/logs/habitat_score_284/summary.csv b/data-raw/logs/habitat_score_284/summary.csv new file mode 100644 index 00000000..b9b373f0 --- /dev/null +++ b/data-raw/logs/habitat_score_284/summary.csv @@ -0,0 +1,289 @@ +"variant","schema","config_name","buffer_m","overlay_applied","watershed_group_code","species_code","stage","n_obs","n_unattached","n_accessible","n_inaccessible","n_spawning","n_rearing","n_rearing_any","n_habitat","share_accessible","share_spawning","share_rearing","share_rearing_any","share_habitat","n_in_uhc_spawn","n_in_uhc_rear","n_obs_outside_uhc_spawn","n_spawning_outside_uhc","n_obs_outside_uhc_rear","n_rearing_any_outside_uhc","share_spawning_outside_uhc","share_rearing_any_outside_uhc","accessible_km","spawning_km","rearing_km","n_absence","n_absence_accessible","n_absence_spawning","n_absence_rearing","n_absence_rearing_any","run_logged" +"default","score284_default","default",0,TRUE,"BABL","BT","any",163,0,163,0,64,105,106,106,1,0.392638036809816,0.644171779141104,0.650306748466258,0.650306748466258,0,0,163,64,163,106,0.392638036809816,0.650306748466258,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BABL","BT","rear",135,0,135,0,47,85,85,85,1,0.348148148148148,0.62962962962963,0.62962962962963,0.62962962962963,0,0,135,47,135,85,0.348148148148148,0.62962962962963,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BABR","BT","any",364,0,363,1,165,263,263,263,0.997252747252747,0.453296703296703,0.722527472527473,0.722527472527473,0.722527472527473,0,0,364,165,364,263,0.453296703296703,0.722527472527473,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BABR","BT","spawn",6,0,6,0,2,4,4,4,1,0.333333333333333,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,2,6,4,0.333333333333333,0.666666666666667,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BABR","BT","rear",225,0,225,0,77,148,148,148,1,0.342222222222222,0.657777777777778,0.657777777777778,0.657777777777778,0,0,225,77,225,148,0.342222222222222,0.657777777777778,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULK","BT","any",468,0,464,4,231,339,339,339,0.991452991452991,0.493589743589744,0.724358974358974,0.724358974358974,0.724358974358974,0,0,468,231,468,339,0.493589743589744,0.724358974358974,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULK","BT","spawn",12,0,12,0,4,9,9,9,1,0.333333333333333,0.75,0.75,0.75,0,0,12,4,12,9,0.333333333333333,0.75,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULK","BT","rear",255,0,252,3,92,162,162,162,0.988235294117647,0.36078431372549,0.635294117647059,0.635294117647059,0.635294117647059,0,0,255,92,255,162,0.36078431372549,0.635294117647059,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULL","BT","any",73,0,73,0,59,64,69,69,1,0.808219178082192,0.876712328767123,0.945205479452055,0.945205479452055,0,0,73,59,73,69,0.808219178082192,0.945205479452055,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",0,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",0,TRUE,"CLRH","BT","any",110,0,108,2,53,75,89,89,0.981818181818182,0.481818181818182,0.681818181818182,0.809090909090909,0.809090909090909,0,0,110,53,110,89,0.481818181818182,0.809090909090909,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",0,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",0,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",0,TRUE,"ELKR","BT","any",582,0,578,4,515,563,564,564,0.993127147766323,0.884879725085911,0.967353951890034,0.969072164948454,0.969072164948454,0,0,582,515,582,564,0.884879725085911,0.969072164948454,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",0,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",0,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",0,TRUE,"KOTL","BT","any",206,0,203,3,116,164,173,173,0.985436893203884,0.563106796116505,0.796116504854369,0.839805825242718,0.839805825242718,0,0,206,116,206,173,0.563106796116505,0.839805825242718,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",0,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",0,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",0,TRUE,"LILL","BT","any",424,0,418,6,320,368,373,373,0.985849056603774,0.754716981132076,0.867924528301887,0.879716981132076,0.879716981132076,0,0,424,320,424,373,0.754716981132076,0.879716981132076,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",0,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",0,TRUE,"LILL","BT","rear",14,0,14,0,7,8,9,9,1,0.5,0.571428571428571,0.642857142857143,0.642857142857143,0,0,14,7,14,9,0.5,0.642857142857143,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",0,TRUE,"MORR","BT","any",357,0,357,0,154,259,266,266,1,0.431372549019608,0.725490196078431,0.745098039215686,0.745098039215686,0,0,357,154,357,266,0.431372549019608,0.745098039215686,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",0,TRUE,"MORR","BT","spawn",23,0,23,0,7,15,15,15,1,0.304347826086957,0.652173913043478,0.652173913043478,0.652173913043478,0,0,23,7,23,15,0.304347826086957,0.652173913043478,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",0,TRUE,"MORR","BT","rear",106,0,106,0,28,63,65,65,1,0.264150943396226,0.594339622641509,0.613207547169811,0.613207547169811,0,0,106,28,106,65,0.264150943396226,0.613207547169811,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",0,TRUE,"PARS","BT","any",281,0,281,0,231,259,259,259,1,0.822064056939502,0.921708185053381,0.921708185053381,0.921708185053381,0,0,281,231,281,259,0.822064056939502,0.921708185053381,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",0,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",0,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",0,TRUE,"REVL","BT","any",308,0,300,8,196,240,252,252,0.974025974025974,0.636363636363636,0.779220779220779,0.818181818181818,0.818181818181818,0,0,308,196,308,252,0.636363636363636,0.818181818181818,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",0,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",0,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",0,TRUE,"UARL","BT","any",242,0,240,2,117,163,165,165,0.991735537190083,0.483471074380165,0.673553719008264,0.681818181818182,0.681818181818182,0,0,242,117,242,165,0.483471074380165,0.681818181818182,1913.74,529.54,776.92,,,,,,TRUE +"default","score284_default","default",0,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,776.92,,,,,,TRUE +"default","score284_default","default",0,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,776.92,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABL","BT","any",163,0,163,0,68,105,106,106,1,0.417177914110429,0.644171779141104,0.650306748466258,0.650306748466258,0,0,163,68,163,106,0.417177914110429,0.650306748466258,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABL","BT","rear",135,0,135,0,51,85,85,85,1,0.377777777777778,0.62962962962963,0.62962962962963,0.62962962962963,0,0,135,51,135,85,0.377777777777778,0.62962962962963,7192.88,1048.06,2055.08,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABR","BT","any",364,0,363,1,182,267,268,268,0.997252747252747,0.5,0.733516483516483,0.736263736263736,0.736263736263736,0,0,364,182,364,268,0.5,0.736263736263736,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABR","BT","spawn",6,0,6,0,3,4,4,4,1,0.5,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,3,6,4,0.5,0.666666666666667,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BABR","BT","rear",225,0,225,0,87,150,151,151,1,0.386666666666667,0.666666666666667,0.671111111111111,0.671111111111111,0,0,225,87,225,151,0.386666666666667,0.671111111111111,4191.18,1000.77,1723.88,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULK","BT","any",468,0,464,4,239,342,342,342,0.991452991452991,0.510683760683761,0.730769230769231,0.730769230769231,0.730769230769231,0,0,468,239,468,342,0.510683760683761,0.730769230769231,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULK","BT","spawn",12,0,12,0,4,9,9,9,1,0.333333333333333,0.75,0.75,0.75,0,0,12,4,12,9,0.333333333333333,0.75,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULK","BT","rear",255,0,252,3,95,163,163,163,0.988235294117647,0.372549019607843,0.63921568627451,0.63921568627451,0.63921568627451,0,0,255,95,255,163,0.372549019607843,0.63921568627451,7661.31,1853.38,3010.32,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULL","BT","any",73,0,73,0,60,64,69,69,1,0.821917808219178,0.876712328767123,0.945205479452055,0.945205479452055,0,0,73,60,73,69,0.821917808219178,0.945205479452055,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",100,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1062.04,,,,,,TRUE +"default","score284_default","default",100,TRUE,"CLRH","BT","any",110,0,108,2,56,78,90,90,0.981818181818182,0.509090909090909,0.709090909090909,0.818181818181818,0.818181818181818,0,0,110,56,110,90,0.509090909090909,0.818181818181818,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",100,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",100,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,988.11,,,,,,TRUE +"default","score284_default","default",100,TRUE,"ELKR","BT","any",582,0,578,4,526,567,568,568,0.993127147766323,0.903780068728522,0.974226804123711,0.97594501718213,0.97594501718213,0,0,582,526,582,568,0.903780068728522,0.97594501718213,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",100,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",100,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2122.71,,,,,,TRUE +"default","score284_default","default",100,TRUE,"KOTL","BT","any",206,0,203,3,127,169,174,174,0.985436893203884,0.616504854368932,0.820388349514563,0.844660194174757,0.844660194174757,0,0,206,127,206,174,0.616504854368932,0.844660194174757,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",100,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",100,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1599.21,,,,,,TRUE +"default","score284_default","default",100,TRUE,"LILL","BT","any",424,0,418,6,351,380,382,382,0.985849056603774,0.827830188679245,0.89622641509434,0.900943396226415,0.900943396226415,0,0,424,351,424,382,0.827830188679245,0.900943396226415,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",100,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",100,TRUE,"LILL","BT","rear",14,0,14,0,7,8,9,9,1,0.5,0.571428571428571,0.642857142857143,0.642857142857143,0,0,14,7,14,9,0.5,0.642857142857143,1649.6,670.34,906.12,,,,,,TRUE +"default","score284_default","default",100,TRUE,"MORR","BT","any",357,0,357,0,162,261,268,268,1,0.453781512605042,0.73109243697479,0.750700280112045,0.750700280112045,0,0,357,162,357,268,0.453781512605042,0.750700280112045,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",100,TRUE,"MORR","BT","spawn",23,0,23,0,8,15,15,15,1,0.347826086956522,0.652173913043478,0.652173913043478,0.652173913043478,0,0,23,8,23,15,0.347826086956522,0.652173913043478,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",100,TRUE,"MORR","BT","rear",106,0,106,0,32,64,66,66,1,0.30188679245283,0.60377358490566,0.622641509433962,0.622641509433962,0,0,106,32,106,66,0.30188679245283,0.622641509433962,4826.91,962.09,1692.1,,,,,,TRUE +"default","score284_default","default",100,TRUE,"PARS","BT","any",281,0,281,0,233,262,262,262,1,0.829181494661922,0.932384341637011,0.932384341637011,0.932384341637011,0,0,281,233,281,262,0.829181494661922,0.932384341637011,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",100,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",100,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2634.99,,,,,,TRUE +"default","score284_default","default",100,TRUE,"REVL","BT","any",308,0,300,8,200,244,255,255,0.974025974025974,0.649350649350649,0.792207792207792,0.827922077922078,0.827922077922078,0,0,308,200,308,255,0.649350649350649,0.827922077922078,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",100,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",100,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,561.14,,,,,,TRUE +"default","score284_default","default",100,TRUE,"UARL","BT","any",242,0,240,2,123,169,169,169,0.991735537190083,0.508264462809917,0.698347107438017,0.698347107438017,0.698347107438017,0,0,242,123,242,169,0.508264462809917,0.698347107438017,1913.74,529.54,776.92,,,,,,TRUE +"default","score284_default","default",100,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,776.92,,,,,,TRUE +"default","score284_default","default",100,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,776.92,,,,,,TRUE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABL","BT","any",163,0,163,0,64,108,109,109,1,0.392638036809816,0.662576687116564,0.668711656441718,0.668711656441718,0,0,163,64,163,109,0.392638036809816,0.668711656441718,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABL","BT","rear",135,0,135,0,47,88,88,88,1,0.348148148148148,0.651851851851852,0.651851851851852,0.651851851851852,0,0,135,47,135,88,0.348148148148148,0.651851851851852,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABR","BT","any",364,0,363,1,165,269,269,269,0.997252747252747,0.453296703296703,0.739010989010989,0.739010989010989,0.739010989010989,0,0,364,165,364,269,0.453296703296703,0.739010989010989,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABR","BT","spawn",6,0,6,0,2,4,4,4,1,0.333333333333333,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,2,6,4,0.333333333333333,0.666666666666667,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BABR","BT","rear",225,0,225,0,77,154,154,154,1,0.342222222222222,0.684444444444444,0.684444444444444,0.684444444444444,0,0,225,77,225,154,0.342222222222222,0.684444444444444,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULK","BT","any",468,0,464,4,231,359,359,359,0.991452991452991,0.493589743589744,0.767094017094017,0.767094017094017,0.767094017094017,0,0,468,231,468,359,0.493589743589744,0.767094017094017,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULK","BT","rear",255,0,252,3,92,178,178,178,0.988235294117647,0.36078431372549,0.698039215686274,0.698039215686274,0.698039215686274,0,0,255,92,255,178,0.36078431372549,0.698039215686274,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULL","BT","any",73,0,73,0,59,65,70,70,1,0.808219178082192,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,59,73,70,0.808219178082192,0.958904109589041,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"CLRH","BT","any",110,0,108,2,53,76,90,90,0.981818181818182,0.481818181818182,0.690909090909091,0.818181818181818,0.818181818181818,0,0,110,53,110,90,0.481818181818182,0.818181818181818,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"ELKR","BT","any",582,0,578,4,515,568,569,569,0.993127147766323,0.884879725085911,0.97594501718213,0.97766323024055,0.97766323024055,0,0,582,515,582,569,0.884879725085911,0.97766323024055,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"KOTL","BT","any",206,0,203,3,116,167,176,176,0.985436893203884,0.563106796116505,0.810679611650485,0.854368932038835,0.854368932038835,0,0,206,116,206,176,0.563106796116505,0.854368932038835,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"LILL","BT","any",424,0,418,6,320,379,384,384,0.985849056603774,0.754716981132076,0.893867924528302,0.905660377358491,0.905660377358491,0,0,424,320,424,384,0.754716981132076,0.905660377358491,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"MORR","BT","any",357,0,357,0,154,267,274,274,1,0.431372549019608,0.747899159663866,0.76750700280112,0.76750700280112,0,0,357,154,357,274,0.431372549019608,0.76750700280112,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"MORR","BT","spawn",23,0,23,0,7,15,15,15,1,0.304347826086957,0.652173913043478,0.652173913043478,0.652173913043478,0,0,23,7,23,15,0.304347826086957,0.652173913043478,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"MORR","BT","rear",106,0,106,0,28,68,70,70,1,0.264150943396226,0.641509433962264,0.660377358490566,0.660377358490566,0,0,106,28,106,70,0.264150943396226,0.660377358490566,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"PARS","BT","any",281,0,281,0,231,265,265,265,1,0.822064056939502,0.94306049822064,0.94306049822064,0.94306049822064,0,0,281,231,281,265,0.822064056939502,0.94306049822064,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"REVL","BT","any",308,0,300,8,196,245,257,257,0.974025974025974,0.636363636363636,0.795454545454545,0.834415584415584,0.834415584415584,0,0,308,196,308,257,0.636363636363636,0.834415584415584,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"UARL","BT","any",242,0,240,2,117,177,179,179,0.991735537190083,0.483471074380165,0.731404958677686,0.739669421487603,0.739669421487603,0,0,242,117,242,179,0.483471074380165,0.739669421487603,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",0,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABL","BT","any",163,0,163,0,68,108,109,109,1,0.417177914110429,0.662576687116564,0.668711656441718,0.668711656441718,0,0,163,68,163,109,0.417177914110429,0.668711656441718,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABL","BT","rear",135,0,135,0,51,88,88,88,1,0.377777777777778,0.651851851851852,0.651851851851852,0.651851851851852,0,0,135,51,135,88,0.377777777777778,0.651851851851852,7192.88,1048.06,2087.11,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABR","BT","any",364,0,363,1,182,273,274,274,0.997252747252747,0.5,0.75,0.752747252747253,0.752747252747253,0,0,364,182,364,274,0.5,0.752747252747253,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABR","BT","spawn",6,0,6,0,3,4,4,4,1,0.5,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,3,6,4,0.5,0.666666666666667,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BABR","BT","rear",225,0,225,0,87,156,157,157,1,0.386666666666667,0.693333333333333,0.697777777777778,0.697777777777778,0,0,225,87,225,157,0.386666666666667,0.697777777777778,4191.18,1000.77,1784.51,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULK","BT","any",468,0,464,4,239,362,362,362,0.991452991452991,0.510683760683761,0.773504273504274,0.773504273504274,0.773504273504274,0,0,468,239,468,362,0.510683760683761,0.773504273504274,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULK","BT","rear",255,0,252,3,95,178,178,178,0.988235294117647,0.372549019607843,0.698039215686274,0.698039215686274,0.698039215686274,0,0,255,95,255,178,0.372549019607843,0.698039215686274,7661.31,1853.38,3131.03,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULL","BT","any",73,0,73,0,60,65,70,70,1,0.821917808219178,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,60,73,70,0.821917808219178,0.958904109589041,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1121.21,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"CLRH","BT","any",110,0,108,2,56,80,91,91,0.981818181818182,0.509090909090909,0.727272727272727,0.827272727272727,0.827272727272727,0,0,110,56,110,91,0.509090909090909,0.827272727272727,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1033.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"ELKR","BT","any",582,0,578,4,526,569,570,570,0.993127147766323,0.903780068728522,0.97766323024055,0.979381443298969,0.979381443298969,0,0,582,526,582,570,0.903780068728522,0.979381443298969,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2243.09,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"KOTL","BT","any",206,0,203,3,127,171,176,176,0.985436893203884,0.616504854368932,0.830097087378641,0.854368932038835,0.854368932038835,0,0,206,127,206,176,0.616504854368932,0.854368932038835,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1706.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"LILL","BT","any",424,0,418,6,351,387,389,389,0.985849056603774,0.827830188679245,0.912735849056604,0.917452830188679,0.917452830188679,0,0,424,351,424,389,0.827830188679245,0.917452830188679,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,941.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"MORR","BT","any",357,0,357,0,162,269,276,276,1,0.453781512605042,0.753501400560224,0.773109243697479,0.773109243697479,0,0,357,162,357,276,0.453781512605042,0.773109243697479,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"MORR","BT","spawn",23,0,23,0,8,15,15,15,1,0.347826086956522,0.652173913043478,0.652173913043478,0.652173913043478,0,0,23,8,23,15,0.347826086956522,0.652173913043478,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"MORR","BT","rear",106,0,106,0,32,69,71,71,1,0.30188679245283,0.650943396226415,0.669811320754717,0.669811320754717,0,0,106,32,106,71,0.30188679245283,0.669811320754717,4826.91,962.09,1741.34,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"PARS","BT","any",281,0,281,0,233,266,266,266,1,0.829181494661922,0.94661921708185,0.94661921708185,0.94661921708185,0,0,281,233,281,266,0.829181494661922,0.94661921708185,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2739.74,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"REVL","BT","any",308,0,300,8,200,248,259,259,0.974025974025974,0.649350649350649,0.805194805194805,0.840909090909091,0.840909090909091,0,0,308,200,308,259,0.649350649350649,0.840909090909091,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,583.68,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"UARL","BT","any",242,0,240,2,123,185,185,185,0.991735537190083,0.508264462809917,0.764462809917355,0.764462809917355,0.764462809917355,0,0,242,123,242,185,0.508264462809917,0.764462809917355,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1249","score284_bt_rear_0p1249","bt_rear_0p1249",100,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,824.07,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABL","BT","any",163,0,163,0,64,114,115,115,1,0.392638036809816,0.699386503067485,0.705521472392638,0.705521472392638,0,0,163,64,163,115,0.392638036809816,0.705521472392638,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABL","BT","rear",135,0,135,0,47,92,92,92,1,0.348148148148148,0.681481481481481,0.681481481481481,0.681481481481481,0,0,135,47,135,92,0.348148148148148,0.681481481481481,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABR","BT","any",364,0,363,1,165,272,272,272,0.997252747252747,0.453296703296703,0.747252747252747,0.747252747252747,0.747252747252747,0,0,364,165,364,272,0.453296703296703,0.747252747252747,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABR","BT","spawn",6,0,6,0,2,4,4,4,1,0.333333333333333,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,2,6,4,0.333333333333333,0.666666666666667,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BABR","BT","rear",225,0,225,0,77,157,157,157,1,0.342222222222222,0.697777777777778,0.697777777777778,0.697777777777778,0,0,225,77,225,157,0.342222222222222,0.697777777777778,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULK","BT","any",468,0,464,4,231,364,364,364,0.991452991452991,0.493589743589744,0.777777777777778,0.777777777777778,0.777777777777778,0,0,468,231,468,364,0.493589743589744,0.777777777777778,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULK","BT","rear",255,0,252,3,92,182,182,182,0.988235294117647,0.36078431372549,0.713725490196078,0.713725490196078,0.713725490196078,0,0,255,92,255,182,0.36078431372549,0.713725490196078,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULL","BT","any",73,0,73,0,59,65,70,70,1,0.808219178082192,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,59,73,70,0.808219178082192,0.958904109589041,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"CLRH","BT","any",110,0,108,2,53,78,92,92,0.981818181818182,0.481818181818182,0.709090909090909,0.836363636363636,0.836363636363636,0,0,110,53,110,92,0.481818181818182,0.836363636363636,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"ELKR","BT","any",582,0,578,4,515,568,569,569,0.993127147766323,0.884879725085911,0.97594501718213,0.97766323024055,0.97766323024055,0,0,582,515,582,569,0.884879725085911,0.97766323024055,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"KOTL","BT","any",206,0,203,3,116,167,176,176,0.985436893203884,0.563106796116505,0.810679611650485,0.854368932038835,0.854368932038835,0,0,206,116,206,176,0.563106796116505,0.854368932038835,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"LILL","BT","any",424,0,418,6,320,382,387,387,0.985849056603774,0.754716981132076,0.900943396226415,0.912735849056604,0.912735849056604,0,0,424,320,424,387,0.754716981132076,0.912735849056604,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"MORR","BT","any",357,0,357,0,154,272,279,279,1,0.431372549019608,0.761904761904762,0.781512605042017,0.781512605042017,0,0,357,154,357,279,0.431372549019608,0.781512605042017,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"MORR","BT","spawn",23,0,23,0,7,16,16,16,1,0.304347826086957,0.695652173913043,0.695652173913043,0.695652173913043,0,0,23,7,23,16,0.304347826086957,0.695652173913043,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"MORR","BT","rear",106,0,106,0,28,71,73,73,1,0.264150943396226,0.669811320754717,0.688679245283019,0.688679245283019,0,0,106,28,106,73,0.264150943396226,0.688679245283019,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"PARS","BT","any",281,0,281,0,231,266,266,266,1,0.822064056939502,0.94661921708185,0.94661921708185,0.94661921708185,0,0,281,231,281,266,0.822064056939502,0.94661921708185,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"REVL","BT","any",308,0,300,8,196,247,259,259,0.974025974025974,0.636363636363636,0.801948051948052,0.840909090909091,0.840909090909091,0,0,308,196,308,259,0.636363636363636,0.840909090909091,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"UARL","BT","any",242,0,240,2,117,182,184,184,0.991735537190083,0.483471074380165,0.752066115702479,0.760330578512397,0.760330578512397,0,0,242,117,242,184,0.483471074380165,0.760330578512397,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",0,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABL","BT","any",163,0,163,0,68,114,115,115,1,0.417177914110429,0.699386503067485,0.705521472392638,0.705521472392638,0,0,163,68,163,115,0.417177914110429,0.705521472392638,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABL","BT","rear",135,0,135,0,51,92,92,92,1,0.377777777777778,0.681481481481481,0.681481481481481,0.681481481481481,0,0,135,51,135,92,0.377777777777778,0.681481481481481,7192.88,1048.06,2096.78,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABR","BT","any",364,0,363,1,182,276,277,277,0.997252747252747,0.5,0.758241758241758,0.760989010989011,0.760989010989011,0,0,364,182,364,277,0.5,0.760989010989011,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABR","BT","spawn",6,0,6,0,3,4,4,4,1,0.5,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,3,6,4,0.5,0.666666666666667,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BABR","BT","rear",225,0,225,0,87,159,160,160,1,0.386666666666667,0.706666666666667,0.711111111111111,0.711111111111111,0,0,225,87,225,160,0.386666666666667,0.711111111111111,4191.18,1000.77,1806.17,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULK","BT","any",468,0,464,4,239,367,367,367,0.991452991452991,0.510683760683761,0.784188034188034,0.784188034188034,0.784188034188034,0,0,468,239,468,367,0.510683760683761,0.784188034188034,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULK","BT","rear",255,0,252,3,95,182,182,182,0.988235294117647,0.372549019607843,0.713725490196078,0.713725490196078,0.713725490196078,0,0,255,95,255,182,0.372549019607843,0.713725490196078,7661.31,1853.38,3168.96,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULL","BT","any",73,0,73,0,60,65,70,70,1,0.821917808219178,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,60,73,70,0.821917808219178,0.958904109589041,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1150.59,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"CLRH","BT","any",110,0,108,2,56,82,93,93,0.981818181818182,0.509090909090909,0.745454545454545,0.845454545454545,0.845454545454545,0,0,110,56,110,93,0.509090909090909,0.845454545454545,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1048.2,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"ELKR","BT","any",582,0,578,4,526,569,570,570,0.993127147766323,0.903780068728522,0.97766323024055,0.979381443298969,0.979381443298969,0,0,582,526,582,570,0.903780068728522,0.979381443298969,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2283.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"KOTL","BT","any",206,0,203,3,127,171,176,176,0.985436893203884,0.616504854368932,0.830097087378641,0.854368932038835,0.854368932038835,0,0,206,127,206,176,0.616504854368932,0.854368932038835,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1741.85,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"LILL","BT","any",424,0,418,6,351,390,392,392,0.985849056603774,0.827830188679245,0.919811320754717,0.924528301886792,0.924528301886792,0,0,424,351,424,392,0.827830188679245,0.924528301886792,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,957.58,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"MORR","BT","any",357,0,357,0,162,274,281,281,1,0.453781512605042,0.76750700280112,0.787114845938375,0.787114845938375,0,0,357,162,357,281,0.453781512605042,0.787114845938375,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"MORR","BT","spawn",23,0,23,0,8,16,16,16,1,0.347826086956522,0.695652173913043,0.695652173913043,0.695652173913043,0,0,23,8,23,16,0.347826086956522,0.695652173913043,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"MORR","BT","rear",106,0,106,0,32,72,74,74,1,0.30188679245283,0.679245283018868,0.69811320754717,0.69811320754717,0,0,106,32,106,74,0.30188679245283,0.69811320754717,4826.91,962.09,1770.21,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"PARS","BT","any",281,0,281,0,233,267,267,267,1,0.829181494661922,0.95017793594306,0.95017793594306,0.95017793594306,0,0,281,233,281,267,0.829181494661922,0.95017793594306,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2775.11,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"REVL","BT","any",308,0,300,8,200,249,260,260,0.974025974025974,0.649350649350649,0.808441558441558,0.844155844155844,0.844155844155844,0,0,308,200,308,260,0.649350649350649,0.844155844155844,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,592.75,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"UARL","BT","any",242,0,240,2,123,190,190,190,0.991735537190083,0.508264462809917,0.785123966942149,0.785123966942149,0.785123966942149,0,0,242,123,242,190,0.508264462809917,0.785123966942149,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1349","score284_bt_rear_0p1349","bt_rear_0p1349",100,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,845.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABL","BT","any",163,0,163,0,64,116,117,117,1,0.392638036809816,0.711656441717791,0.717791411042945,0.717791411042945,0,0,163,64,163,117,0.392638036809816,0.717791411042945,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABL","BT","rear",135,0,135,0,47,94,94,94,1,0.348148148148148,0.696296296296296,0.696296296296296,0.696296296296296,0,0,135,47,135,94,0.348148148148148,0.696296296296296,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABR","BT","any",364,0,363,1,165,272,272,272,0.997252747252747,0.453296703296703,0.747252747252747,0.747252747252747,0.747252747252747,0,0,364,165,364,272,0.453296703296703,0.747252747252747,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABR","BT","spawn",6,0,6,0,2,4,4,4,1,0.333333333333333,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,2,6,4,0.333333333333333,0.666666666666667,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BABR","BT","rear",225,0,225,0,77,157,157,157,1,0.342222222222222,0.697777777777778,0.697777777777778,0.697777777777778,0,0,225,77,225,157,0.342222222222222,0.697777777777778,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULK","BT","any",468,0,464,4,231,368,368,368,0.991452991452991,0.493589743589744,0.786324786324786,0.786324786324786,0.786324786324786,0,0,468,231,468,368,0.493589743589744,0.786324786324786,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULK","BT","rear",255,0,252,3,92,182,182,182,0.988235294117647,0.36078431372549,0.713725490196078,0.713725490196078,0.713725490196078,0,0,255,92,255,182,0.36078431372549,0.713725490196078,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULL","BT","any",73,0,73,0,59,65,70,70,1,0.808219178082192,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,59,73,70,0.808219178082192,0.958904109589041,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"CLRH","BT","any",110,0,108,2,53,78,92,92,0.981818181818182,0.481818181818182,0.709090909090909,0.836363636363636,0.836363636363636,0,0,110,53,110,92,0.481818181818182,0.836363636363636,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"ELKR","BT","any",582,0,578,4,515,570,571,571,0.993127147766323,0.884879725085911,0.979381443298969,0.981099656357388,0.981099656357388,0,0,582,515,582,571,0.884879725085911,0.981099656357388,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"KOTL","BT","any",206,0,203,3,116,167,176,176,0.985436893203884,0.563106796116505,0.810679611650485,0.854368932038835,0.854368932038835,0,0,206,116,206,176,0.563106796116505,0.854368932038835,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"LILL","BT","any",424,0,418,6,320,383,388,388,0.985849056603774,0.754716981132076,0.903301886792453,0.915094339622642,0.915094339622642,0,0,424,320,424,388,0.754716981132076,0.915094339622642,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"MORR","BT","any",357,0,357,0,154,277,284,284,1,0.431372549019608,0.775910364145658,0.795518207282913,0.795518207282913,0,0,357,154,357,284,0.431372549019608,0.795518207282913,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"MORR","BT","spawn",23,0,23,0,7,16,16,16,1,0.304347826086957,0.695652173913043,0.695652173913043,0.695652173913043,0,0,23,7,23,16,0.304347826086957,0.695652173913043,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"MORR","BT","rear",106,0,106,0,28,73,75,75,1,0.264150943396226,0.688679245283019,0.707547169811321,0.707547169811321,0,0,106,28,106,75,0.264150943396226,0.707547169811321,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"PARS","BT","any",281,0,281,0,231,266,266,266,1,0.822064056939502,0.94661921708185,0.94661921708185,0.94661921708185,0,0,281,231,281,266,0.822064056939502,0.94661921708185,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"REVL","BT","any",308,0,300,8,196,247,259,259,0.974025974025974,0.636363636363636,0.801948051948052,0.840909090909091,0.840909090909091,0,0,308,196,308,259,0.636363636363636,0.840909090909091,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"UARL","BT","any",242,0,240,2,117,185,187,187,0.991735537190083,0.483471074380165,0.764462809917355,0.772727272727273,0.772727272727273,0,0,242,117,242,187,0.483471074380165,0.772727272727273,1913.74,529.54,860.19,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,860.19,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",0,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,860.19,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABL","BT","any",163,0,163,0,68,116,117,117,1,0.417177914110429,0.711656441717791,0.717791411042945,0.717791411042945,0,0,163,68,163,117,0.417177914110429,0.717791411042945,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABL","BT","spawn",3,0,3,0,1,1,1,1,1,0.333333333333333,0.333333333333333,0.333333333333333,0.333333333333333,0,0,3,1,3,1,0.333333333333333,0.333333333333333,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABL","BT","rear",135,0,135,0,51,94,94,94,1,0.377777777777778,0.696296296296296,0.696296296296296,0.696296296296296,0,0,135,51,135,94,0.377777777777778,0.696296296296296,7192.88,1048.06,2104.52,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABR","BT","any",364,0,363,1,182,276,277,277,0.997252747252747,0.5,0.758241758241758,0.760989010989011,0.760989010989011,0,0,364,182,364,277,0.5,0.760989010989011,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABR","BT","spawn",6,0,6,0,3,4,4,4,1,0.5,0.666666666666667,0.666666666666667,0.666666666666667,0,0,6,3,6,4,0.5,0.666666666666667,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BABR","BT","rear",225,0,225,0,87,159,160,160,1,0.386666666666667,0.706666666666667,0.711111111111111,0.711111111111111,0,0,225,87,225,160,0.386666666666667,0.711111111111111,4191.18,1000.77,1818.81,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULK","BT","any",468,0,464,4,239,370,370,370,0.991452991452991,0.510683760683761,0.790598290598291,0.790598290598291,0.790598290598291,0,0,468,239,468,370,0.510683760683761,0.790598290598291,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULK","BT","spawn",12,0,12,0,4,10,10,10,1,0.333333333333333,0.833333333333333,0.833333333333333,0.833333333333333,0,0,12,4,12,10,0.333333333333333,0.833333333333333,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULK","BT","rear",255,0,252,3,95,182,182,182,0.988235294117647,0.372549019607843,0.713725490196078,0.713725490196078,0.713725490196078,0,0,255,95,255,182,0.372549019607843,0.713725490196078,7661.31,1853.38,3213.68,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULL","BT","any",73,0,73,0,60,65,70,70,1,0.821917808219178,0.89041095890411,0.958904109589041,0.958904109589041,0,0,73,60,73,70,0.821917808219178,0.958904109589041,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"BULL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2695.48,715.43,1168.28,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"CLRH","BT","any",110,0,108,2,56,82,93,93,0.981818181818182,0.509090909090909,0.745454545454545,0.845454545454545,0.845454545454545,0,0,110,56,110,93,0.509090909090909,0.845454545454545,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"CLRH","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"CLRH","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,2121.34,733.49,1063.72,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"ELKR","BT","any",582,0,578,4,526,570,571,571,0.993127147766323,0.903780068728522,0.979381443298969,0.981099656357388,0.981099656357388,0,0,582,526,582,571,0.903780068728522,0.981099656357388,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"ELKR","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"ELKR","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,4325.16,1536.57,2330.82,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"KOTL","BT","any",206,0,203,3,127,171,176,176,0.985436893203884,0.616504854368932,0.830097087378641,0.854368932038835,0.854368932038835,0,0,206,127,206,176,0.616504854368932,0.854368932038835,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"KOTL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"KOTL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,3619.68,1035.17,1778.67,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"LILL","BT","any",424,0,418,6,351,391,393,393,0.985849056603774,0.827830188679245,0.922169811320755,0.92688679245283,0.92688679245283,0,0,424,351,424,393,0.827830188679245,0.92688679245283,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"LILL","BT","spawn",9,0,9,0,5,6,6,6,1,0.555555555555556,0.666666666666667,0.666666666666667,0.666666666666667,0,0,9,5,9,6,0.555555555555556,0.666666666666667,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"LILL","BT","rear",14,0,14,0,7,9,10,10,1,0.5,0.642857142857143,0.714285714285714,0.714285714285714,0,0,14,7,14,10,0.5,0.714285714285714,1649.6,670.34,967.58,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"MORR","BT","any",357,0,357,0,162,279,286,286,1,0.453781512605042,0.781512605042017,0.801120448179272,0.801120448179272,0,0,357,162,357,286,0.453781512605042,0.801120448179272,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"MORR","BT","spawn",23,0,23,0,8,16,16,16,1,0.347826086956522,0.695652173913043,0.695652173913043,0.695652173913043,0,0,23,8,23,16,0.347826086956522,0.695652173913043,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"MORR","BT","rear",106,0,106,0,32,74,76,76,1,0.30188679245283,0.69811320754717,0.716981132075472,0.716981132075472,0,0,106,32,106,76,0.30188679245283,0.716981132075472,4826.91,962.09,1786.66,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"PARS","BT","any",281,0,281,0,233,267,267,267,1,0.829181494661922,0.95017793594306,0.95017793594306,0.95017793594306,0,0,281,233,281,267,0.829181494661922,0.95017793594306,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"PARS","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"PARS","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,6883.03,1685.39,2798.86,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"REVL","BT","any",308,0,300,8,200,249,260,260,0.974025974025974,0.649350649350649,0.808441558441558,0.844155844155844,0.844155844155844,0,0,308,200,308,260,0.649350649350649,0.844155844155844,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"REVL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"REVL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1133.84,412.05,604.71,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"UARL","BT","any",242,0,240,2,123,193,193,193,0.991735537190083,0.508264462809917,0.797520661157025,0.797520661157025,0.797520661157025,0,0,242,123,242,193,0.508264462809917,0.797520661157025,1913.74,529.54,860.19,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"UARL","BT","spawn",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,860.19,,,,,,FALSE +"bt_rear_0p1449","score284_bt_rear_0p1449","bt_rear_0p1449",100,TRUE,"UARL","BT","rear",0,0,0,0,0,0,0,0,,,,,,0,0,0,0,0,0,,,1913.74,529.54,860.19,,,,,,FALSE diff --git a/data-raw/logs/habitat_score_284/taper.csv b/data-raw/logs/habitat_score_284/taper.csv new file mode 100644 index 00000000..ce136cfe --- /dev/null +++ b/data-raw/logs/habitat_score_284/taper.csv @@ -0,0 +1,15 @@ +"species_code","column","role","taper_class","km","n","per_100km","ratio_to_core" +"BT","rear_gradient_max","held_out","band bt_rear_0p1249",422.199474061986,46,10.895323851883,0.603411835497523 +"BT","rear_gradient_max","held_out","band bt_rear_0p1349",163.041225190392,21,12.8801779890191,0.713338304353902 +"BT","rear_gradient_max","held_out","band bt_rear_0p1449",137.509597013536,8,5.81777575801674,0.322203800123956 +"BT","rear_gradient_max","held_out","core (-Inf,0.02]",4872.14486710653,908,18.6365558653686,1.03214172749264 +"BT","rear_gradient_max","held_out","core (0.02,0.05]",3045.06828125025,603,19.8025116123971,1.09671543883778 +"BT","rear_gradient_max","held_out","core (0.05,0.08]",1591.86910304486,249,15.6419896286524,0.866294733499562 +"BT","rear_gradient_max","held_out","core (0.08, Inf]",686.862396530564,81,11.7927550567832,0.653113947884755 +"BT","rear_gradient_max","in_sample","band bt_rear_0p1249",383.636642052419,39,10.1658693995844,0.890601419706828 +"BT","rear_gradient_max","in_sample","band bt_rear_0p1349",137.577626542057,11,7.99548609499912,0.700460628359393 +"BT","rear_gradient_max","in_sample","band bt_rear_0p1449",121.754733275809,9,7.39190974991701,0.647583109604966 +"BT","rear_gradient_max","in_sample","core (-Inf,0.02]",4295.08325339547,499,11.6179354522527,1.0178125845549 +"BT","rear_gradient_max","in_sample","core (0.02,0.05]",2553.40360190603,299,11.7098605084134,1.02586586384715 +"BT","rear_gradient_max","in_sample","core (0.05,0.08]",1443.37050177981,151,10.4616243586662,0.916511627293637 +"BT","rear_gradient_max","in_sample","core (0.08, Inf]",644.057638424171,71,11.023858077938,0.965767242225203 diff --git a/data-raw/logs/habitat_score_284/totals.csv b/data-raw/logs/habitat_score_284/totals.csv new file mode 100644 index 00000000..1293a216 --- /dev/null +++ b/data-raw/logs/habitat_score_284/totals.csv @@ -0,0 +1,49 @@ +"variant","buffer_m","species_code","role","stage","n_obs","n_accessible","n_spawning","n_rearing","n_rearing_any","n_obs_outside_uhc_spawn","n_spawning_outside_uhc","n_obs_outside_uhc_rear","n_rearing_any_outside_uhc","accessible_km","spawning_km","rearing_km","share_accessible","share_spawning","share_rearing","share_rearing_any" +"bt_rear_0p1249",0,"BT","held_out","any",2266,2243,1489,1887,1927,2266,1489,2266,1927,25223.22,6646.25,10618.08,0.989849955869373,0.657105030891439,0.832744924977935,0.850397175639894 +"bt_rear_0p1349",0,"BT","held_out","any",2266,2243,1489,1908,1948,2266,1489,2266,1948,25223.22,6646.25,10781.11,0.989849955869373,0.657105030891439,0.842012356575463,0.859664607237423 +"bt_rear_0p1449",0,"BT","held_out","any",2266,2243,1489,1916,1956,2266,1489,2266,1956,25223.22,6646.25,10918.63,0.989849955869373,0.657105030891439,0.845542806707855,0.863195057369815 +"default",0,"BT","held_out","any",2266,2243,1489,1841,1881,2266,1489,2266,1881,25223.22,6646.25,10196,0.989849955869373,0.657105030891439,0.812444836716681,0.830097087378641 +"bt_rear_0p1249",100,"BT","held_out","any",2266,2243,1566,1915,1947,2266,1566,2266,1947,25223.22,6646.25,10618.08,0.989849955869373,0.69108561341571,0.845101500441306,0.859223300970874 +"bt_rear_0p1349",100,"BT","held_out","any",2266,2243,1566,1935,1967,2266,1566,2266,1967,25223.22,6646.25,10781.11,0.989849955869373,0.69108561341571,0.853927625772286,0.868049426301853 +"bt_rear_0p1449",100,"BT","held_out","any",2266,2243,1566,1942,1974,2266,1566,2266,1974,25223.22,6646.25,10918.63,0.989849955869373,0.69108561341571,0.857016769638129,0.871138570167696 +"default",100,"BT","held_out","any",2266,2243,1566,1874,1907,2266,1566,2266,1907,25223.22,6646.25,10196,0.989849955869373,0.69108561341571,0.827007943512798,0.841571050308914 +"bt_rear_0p1249",0,"BT","in_sample","any",1312,1305,732,1058,1074,1312,732,1312,1074,22990.93,5536.03,9318.85,0.994664634146341,0.557926829268293,0.80640243902439,0.81859756097561 +"bt_rear_0p1349",0,"BT","in_sample","any",1312,1305,732,1069,1085,1312,732,1312,1085,22990.93,5536.03,9456.13,0.994664634146341,0.557926829268293,0.814786585365854,0.826981707317073 +"bt_rear_0p1449",0,"BT","in_sample","any",1312,1305,732,1078,1094,1312,732,1312,1094,22990.93,5536.03,9577.87,0.994664634146341,0.557926829268293,0.821646341463415,0.833841463414634 +"default",0,"BT","in_sample","any",1312,1305,732,1021,1037,1312,732,1312,1037,22990.93,5536.03,8936.62,0.994664634146341,0.557926829268293,0.778201219512195,0.790396341463415 +"bt_rear_0p1249",100,"BT","in_sample","any",1312,1305,761,1068,1080,1312,761,1312,1080,22990.93,5536.03,9318.85,0.994664634146341,0.580030487804878,0.814024390243902,0.823170731707317 +"bt_rear_0p1349",100,"BT","in_sample","any",1312,1305,761,1079,1091,1312,761,1312,1091,22990.93,5536.03,9456.13,0.994664634146341,0.580030487804878,0.822408536585366,0.83155487804878 +"bt_rear_0p1449",100,"BT","in_sample","any",1312,1305,761,1087,1099,1312,761,1312,1099,22990.93,5536.03,9577.87,0.994664634146341,0.580030487804878,0.828506097560976,0.83765243902439 +"default",100,"BT","in_sample","any",1312,1305,761,1034,1046,1312,761,1312,1046,22990.93,5536.03,8936.62,0.994664634146341,0.580030487804878,0.788109756097561,0.797256097560976 +"bt_rear_0p1249",0,"BT","held_out","rear",374,374,131,251,252,374,131,374,252,25223.22,6646.25,10618.08,1,0.350267379679144,0.671122994652406,0.67379679144385 +"bt_rear_0p1349",0,"BT","held_out","rear",374,374,131,258,259,374,131,374,259,25223.22,6646.25,10781.11,1,0.350267379679144,0.689839572192513,0.692513368983957 +"bt_rear_0p1449",0,"BT","held_out","rear",374,374,131,260,261,374,131,374,261,25223.22,6646.25,10918.63,1,0.350267379679144,0.695187165775401,0.697860962566845 +"default",0,"BT","held_out","rear",374,374,131,241,242,374,131,374,242,25223.22,6646.25,10196,1,0.350267379679144,0.644385026737968,0.647058823529412 +"bt_rear_0p1249",100,"BT","held_out","rear",374,374,145,253,255,374,145,374,255,25223.22,6646.25,10618.08,1,0.387700534759358,0.676470588235294,0.681818181818182 +"bt_rear_0p1349",100,"BT","held_out","rear",374,374,145,260,262,374,145,374,262,25223.22,6646.25,10781.11,1,0.387700534759358,0.695187165775401,0.700534759358289 +"bt_rear_0p1449",100,"BT","held_out","rear",374,374,145,262,264,374,145,374,264,25223.22,6646.25,10918.63,1,0.387700534759358,0.700534759358289,0.705882352941177 +"default",100,"BT","held_out","rear",374,374,145,243,245,374,145,374,245,25223.22,6646.25,10196,1,0.387700534759358,0.649732620320856,0.655080213903743 +"bt_rear_0p1249",0,"BT","in_sample","rear",361,358,120,246,248,361,120,361,248,22990.93,5536.03,9318.85,0.991689750692521,0.332409972299169,0.681440443213296,0.686980609418283 +"bt_rear_0p1349",0,"BT","in_sample","rear",361,358,120,253,255,361,120,361,255,22990.93,5536.03,9456.13,0.991689750692521,0.332409972299169,0.700831024930748,0.706371191135734 +"bt_rear_0p1449",0,"BT","in_sample","rear",361,358,120,255,257,361,120,361,257,22990.93,5536.03,9577.87,0.991689750692521,0.332409972299169,0.706371191135734,0.71191135734072 +"default",0,"BT","in_sample","rear",361,358,120,225,227,361,120,361,227,22990.93,5536.03,8936.62,0.991689750692521,0.332409972299169,0.623268698060942,0.628808864265928 +"bt_rear_0p1249",100,"BT","in_sample","rear",361,358,127,247,249,361,127,361,249,22990.93,5536.03,9318.85,0.991689750692521,0.35180055401662,0.68421052631579,0.689750692520776 +"bt_rear_0p1349",100,"BT","in_sample","rear",361,358,127,254,256,361,127,361,256,22990.93,5536.03,9456.13,0.991689750692521,0.35180055401662,0.703601108033241,0.709141274238227 +"bt_rear_0p1449",100,"BT","in_sample","rear",361,358,127,256,258,361,127,361,258,22990.93,5536.03,9577.87,0.991689750692521,0.35180055401662,0.709141274238227,0.714681440443213 +"default",100,"BT","in_sample","rear",361,358,127,227,229,361,127,361,229,22990.93,5536.03,8936.62,0.991689750692521,0.35180055401662,0.628808864265928,0.634349030470914 +"bt_rear_0p1249",0,"BT","held_out","spawn",18,18,8,11,11,18,8,18,11,25223.22,6646.25,10618.08,1,0.444444444444444,0.611111111111111,0.611111111111111 +"bt_rear_0p1349",0,"BT","held_out","spawn",18,18,8,11,11,18,8,18,11,25223.22,6646.25,10781.11,1,0.444444444444444,0.611111111111111,0.611111111111111 +"bt_rear_0p1449",0,"BT","held_out","spawn",18,18,8,11,11,18,8,18,11,25223.22,6646.25,10918.63,1,0.444444444444444,0.611111111111111,0.611111111111111 +"default",0,"BT","held_out","spawn",18,18,8,11,11,18,8,18,11,25223.22,6646.25,10196,1,0.444444444444444,0.611111111111111,0.611111111111111 +"bt_rear_0p1249",100,"BT","held_out","spawn",18,18,9,11,11,18,9,18,11,25223.22,6646.25,10618.08,1,0.5,0.611111111111111,0.611111111111111 +"bt_rear_0p1349",100,"BT","held_out","spawn",18,18,9,11,11,18,9,18,11,25223.22,6646.25,10781.11,1,0.5,0.611111111111111,0.611111111111111 +"bt_rear_0p1449",100,"BT","held_out","spawn",18,18,9,11,11,18,9,18,11,25223.22,6646.25,10918.63,1,0.5,0.611111111111111,0.611111111111111 +"default",100,"BT","held_out","spawn",18,18,9,11,11,18,9,18,11,25223.22,6646.25,10196,1,0.5,0.611111111111111,0.611111111111111 +"bt_rear_0p1249",0,"BT","in_sample","spawn",35,35,11,25,25,35,11,35,25,22990.93,5536.03,9318.85,1,0.314285714285714,0.714285714285714,0.714285714285714 +"bt_rear_0p1349",0,"BT","in_sample","spawn",35,35,11,26,26,35,11,35,26,22990.93,5536.03,9456.13,1,0.314285714285714,0.742857142857143,0.742857142857143 +"bt_rear_0p1449",0,"BT","in_sample","spawn",35,35,11,26,26,35,11,35,26,22990.93,5536.03,9577.87,1,0.314285714285714,0.742857142857143,0.742857142857143 +"default",0,"BT","in_sample","spawn",35,35,11,24,24,35,11,35,24,22990.93,5536.03,8936.62,1,0.314285714285714,0.685714285714286,0.685714285714286 +"bt_rear_0p1249",100,"BT","in_sample","spawn",35,35,12,25,25,35,12,35,25,22990.93,5536.03,9318.85,1,0.342857142857143,0.714285714285714,0.714285714285714 +"bt_rear_0p1349",100,"BT","in_sample","spawn",35,35,12,26,26,35,12,35,26,22990.93,5536.03,9456.13,1,0.342857142857143,0.742857142857143,0.742857142857143 +"bt_rear_0p1449",100,"BT","in_sample","spawn",35,35,12,26,26,35,12,35,26,22990.93,5536.03,9577.87,1,0.342857142857143,0.742857142857143,0.742857142857143 +"default",100,"BT","in_sample","spawn",35,35,12,24,24,35,12,35,24,22990.93,5536.03,8936.62,1,0.342857142857143,0.685714285714286,0.685714285714286 diff --git a/data-raw/logs/habitat_score_284/verdict.csv b/data-raw/logs/habitat_score_284/verdict.csv new file mode 100644 index 00000000..53b6dee5 --- /dev/null +++ b/data-raw/logs/habitat_score_284/verdict.csv @@ -0,0 +1,4 @@ +"variant","step_from","column","value_from","value","step_direction","obs_stage","species_code","flag","role","direction","stage","band_km","n_band","core_km","n_core","density_band","density_core","density_ratio","band_is_habitat","decision","n_expected","decision_expected_floor","ladder_tip","walk_status","walked_value","walk_status_expected_floor","walked_value_expected_floor" +"bt_rear_0p1249","default","rear_gradient_max",0.1049,0.1249,"added","any","BT","rearing","held_out","added","any",422.134460851787,46,10195.9446479322,1841,0.108970018479848,0.180561984550727,0.603504767357241,TRUE,"take",76.2214359986498,"take","bt_rear_0p1449","underpowered at bt_rear_0p1449 - the step 1-4 verdict stands",,"refused at bt_rear_0p1449",0.1349 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","added","any",163.041225190392,21,10195.9446479322,1841,0.128801779890191,0.180561984550727,0.713338304353903,TRUE,"take",29.4390471839592,"take","bt_rear_0p1449","underpowered at bt_rear_0p1449 - the step 1-4 verdict stands",,"refused at bt_rear_0p1449",0.1349 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","added","any",137.509597013536,8,10195.9446479322,1841,0.0581777575801674,0.180561984550727,0.322203800123957,FALSE,"keep (n < 10)",24.8290057315348,"refuse","bt_rear_0p1449","underpowered at bt_rear_0p1449 - the step 1-4 verdict stands",,"refused at bt_rear_0p1449",0.1349 diff --git a/inst/extdata/configs/default_tuned/README.md b/inst/extdata/configs/default_tuned/README.md index 14b52eb9..281f0bf4 100644 --- a/inst/extdata/configs/default_tuned/README.md +++ b/inst/extdata/configs/default_tuned/README.md @@ -11,7 +11,7 @@ Everything else — `rules.yaml`, `dimensions.csv`, `parameters_fresh.csv`, `ove ## Status -One cell differs from `default` (link#284): BT `rear_gradient_max` 0.1049 → 0.1349, from BT and DV records pooled (BT records alone give 0.1249; both are in the research doc). The other CH and BT gradient maxima and channel-width minima were examined and kept, as were `spawn_gradient_min` and `cluster_bridge_gradient` in the inherited `parameters_fresh.csv`. Channel-width maxima, MAD, lake area and edge types were out of scope and are unchanged. The evidence for each value, changed or kept, is in [`research/habitat_thresholds.md`](../../../../research/habitat_thresholds.md). The values are **candidates, unscored**: they have not yet been run against the observation validation (link#283). +One cell differs from `default` (link#284): BT `rear_gradient_max` 0.1049 → 0.1349, from BT and DV records pooled (BT records alone give 0.1249; both are in the research doc). The other CH and BT gradient maxima and channel-width minima were examined and kept, as were `spawn_gradient_min` and `cluster_bridge_gradient` in the inherited `parameters_fresh.csv`. Channel-width maxima, MAD, lake area and edge types were out of scope and are unchanged. The evidence for each value, changed or kept, is in [`research/habitat_thresholds.md`](../../../../research/habitat_thresholds.md). The BT value was **scored** against fish observations on eight watershed groups held out from its calibration (link#284 step 5) and held: the steps to 0.1349 add rearing that BT use at 0.60–0.71 of the core rate (0.75–0.89 at the same elevation), and the step past it does not. The kept CH values could not be scored with the data available; the other kept BT values were not tested. ## When you change a value diff --git a/inst/extdata/configs/default_tuned/config.yaml b/inst/extdata/configs/default_tuned/config.yaml index b4a229ff..872ed73f 100644 --- a/inst/extdata/configs/default_tuned/config.yaml +++ b/inst/extdata/configs/default_tuned/config.yaml @@ -6,8 +6,9 @@ description: | the persist schema. From link#284 it differs from default in one cell: BT rear_gradient_max 0.1049 -> 0.1349 (BT and DV records pooled). Evidence, and the gradient and width values that were examined and kept, are in - research/habitat_thresholds.md; the candidates are unscored until the - observation validation (link#283) runs. + research/habitat_thresholds.md. The BT value was scored against held-out + fish observations (link#284 step 5) and held; the kept CH values are + unscored. extends: default diff --git a/planning/active/findings.md b/planning/active/findings.md index 4bd0fab7..e9464b24 100644 --- a/planning/active/findings.md +++ b/planning/active/findings.md @@ -95,8 +95,14 @@ files, about 11.8k lines), so an unpinned re-run would have differed for input r Removing the `BT,caught,Dolly Varden` row moves BT absences 1535 → 1539 (the data drives the rule). +## Step 5 results (2026-09-29) + +Held out, core 18.1 locations per 100 km: bands 0.60 / 0.71 / 0.32 (elevation-adjusted 0.75 / 0.89 / 0.40); found 46 / 21 / 8 against 76 / 29 / 25 expected. 0.1349 holds under both floors. Capture 81.2 % → 84.2 % for +585 km (+5.7 %). The core itself tapers (18.6 / 19.8 / 15.6 / 11.8 per 100 km at ≤ 2 / 2–5 / 5–8 / 8–10.5 %) and thins with elevation (24.6 / 19.3 / 10.2). Of the bands, 67–74 % is bridge-only; 101 km of the first band is outside its gradient window (connectivity-admitted). The recompute changed REVL's access (cross-WSG). All in `research/habitat_thresholds.md` "Step 5, Results". + ## Errors Encountered | Error | Resolution | |-------|------------| | `DISTINCT ON` probe gave staged CH counts differing by one between runs | aggregate per location with `bool_or`, as the validator dedups | +| Scoring stopped: steps moved habitat against their direction (BULK, KOTL, LILL) | clustering merges; 1.1 km vs 1,365 km. Guard now tolerates <= 1 % of a step and reports the km | +| BULL pre-flight: variant access check could never pass | dropped the check (a variant persists one species' access); access copied from the base | diff --git a/planning/active/progress.md b/planning/active/progress.md index 47a6e2ca..ad77005d 100644 --- a/planning/active/progress.md +++ b/planning/active/progress.md @@ -12,3 +12,6 @@ - Phase 3 code written (`habitat_variants_build.R`, `habitat_variants_score.R`), review gaps G1–G8, AC1, AC4 folded in. - Code-check: 5 rounds plus an enumeration. Rounds 3, 4 and 5 each found a defect inside the previous fix (the per-row walk, bundle provenance, the resume key). All fixed and probed. Summary in `review-enumeration.md`. - BULL pre-flight: invariants hold, bands reconcile, and the pipeline runs end to end. Next: commit, drop the pre-flight scratch schemas, launch the full build detached. +- Build run `20260930_014921-53610765`: 139.6 min, every post-condition met in the DB. The scoring stopped once on the nesting guard (1.1 km moved against direction by clustering); it now tolerates up to 1 % and reports it. +- Discussed with the operator: the n >= 10 floor (found vs expected), 0.5 as a cutoff, the temperature/elevation confound, weights instead of cutoffs. Added the taper, the elevation split, the elevation-adjusted ratio and the expected-floor reading. Filed knowledge#28 (the biology of habitat weights). +- Verdict: 0.1349 held under both floors; `default_tuned` unchanged. diff --git a/planning/active/task_plan.md b/planning/active/task_plan.md index 95cc0c1c..31903c5e 100644 --- a/planning/active/task_plan.md +++ b/planning/active/task_plan.md @@ -91,29 +91,29 @@ steps. Decided: - [x] `/code-check`: 5 rounds and an enumeration (`review-round1..5.md`, `review-enumeration.md`). ## Phase 4: Full build -- [ ] Restate the run decisions and launch detached (`nohup … & disown`). The repo is not touched while it runs. -- [ ] Verify post-conditions against the DB, not the exit code: +- [x] Restate the run decisions and launch detached (`nohup … & disown`). The repo is not touched while it runs. +- [x] Verify post-conditions against the DB, not the exit code (23 base WSGs clean at `a11a001`; 12 recompute rows, with REVL's access changed; 12 BT WSGs per variant; `built.csv` 48 rows): - 23 WSGs in `score284_default`; - the 12 focal WSGs in each variant schema (BT); - the invariants from Phase 3; - `.log` rows present for the base run. -- [ ] Commit the run log and stamp to `data-raw/logs/habitat_score_284/` (redacted). +- [x] Commit the run log and stamp to `data-raw/logs/habitat_score_284/` (redacted). ## Phase 5: Score -- [ ] `data-raw/habitat_variants_score.R` sources `habitat_validate_inputs.R` for pooling (from `default`'s tracker) and absences, then runs `lnk_habitat_validate()` on every variant schema at buffers 0 and 100. Output: `summary.csv`, `totals.csv`. -- [ ] Bands per ladder step via `lnk_habitat_validate_band()` → `bands.csv`, which holds held-out and in-sample rows, the absence count in each band, and `n` and `density_ratio`. -- [ ] Apply the rule mechanically → `verdict.csv` (per ladder step: pass, fail or keep with n < 10, then the walked-out value). -- [ ] Question 2: the km of BT rearing newly admitted in each band that has spawning upstream (`fwa_upstream`) against bridge-only. Output: `bridge_band.csv`. +- [x] `data-raw/habitat_variants_score.R` sources `habitat_validate_inputs.R` for pooling (from `default`'s tracker) and absences, then runs `lnk_habitat_validate()` on every variant schema at buffers 0 and 100. Output: `summary.csv`, `totals.csv`. +- [x] Bands per ladder step via `lnk_habitat_validate_band()` → `bands.csv`, which holds held-out and in-sample rows, the absence count in each band, and `n` and `density_ratio`. +- [x] Apply the rule mechanically (plus the expected-count floor beside it, discussed with the operator after the build; the two agree) → `verdict.csv` (per ladder step: pass, fail or keep with n < 10, then the walked-out value). +- [x] Question 2: the km of BT rearing newly admitted in each band that has spawning upstream (`fwa_upstream`) against bridge-only. Output: `bridge_band.csv`. - [x] Question 3 (the CH spawn 0.0299 band): dropped with CH; the research doc records it as unscorable (0 held-out spawn-staged locations). ## Phase 6: Verdict and landing -- [ ] Revise `research/habitat_thresholds.md` in place: +- [x] Revise `research/habitat_thresholds.md` in place (also: taper, elevation split and elevation-adjusted ratio; weights spun out to knowledge#28): - the verdict table, now scored; - the Step 5 results; - the header status line. -- [ ] Update `habitat_validation.md`'s "Using it for #284 step 5" section. -- [ ] If the rule moves a value, edit `configs/default_tuned/parameters_habitat_thresholds.csv`, its `config.yaml` checksum and README, then check with `lnk_config_verify()` and `audit_configs.R`. If not, the README and config description lose "unscored". -- [ ] Update NEWS.md, the CLAUDE.md status and the #284 issue body (edited, not appended). +- [x] Update `habitat_validation.md`'s "Using it for #284 step 5" section. +- [x] If the rule moves a value (it did not: 0.1349 held), edit `configs/default_tuned/parameters_habitat_thresholds.csv`, its `config.yaml` checksum and README, then check with `lnk_config_verify()` and `audit_configs.R`. If not, the README and config description lose "unscored". +- [x] CLAUDE.md status; #284 issue body (edited, not appended). NEWS and the version bump are `/gh-pr-merge`'s. ## Validation diff --git a/research/habitat_thresholds.md b/research/habitat_thresholds.md index 634dbcd6..2b9a014f 100644 --- a/research/habitat_thresholds.md +++ b/research/habitat_thresholds.md @@ -1,6 +1,6 @@ # Habitat thresholds — CH and BT gradient and channel width -**Verified:** 2026-09-27 · **Issues:** #284 (this), #290 (the pooling tracker), #283 (the validator, [`habitat_validation.md`](habitat_validation.md)), #282 (`default_tuned`) · **Produced by:** `data-raw/query_habitat_thresholds_obs.R`, `data-raw/query_habitat_thresholds_fiss.R` → `data-raw/logs/habitat_thresholds_284/`; literature review archived with #284's PWF (`literature.md`) · **Status:** candidates set in `default_tuned`, **unscored** +**Verified:** 2026-09-29 · **Issues:** #284 (this), #290 (the pooling tracker), #283 (the validator, [`habitat_validation.md`](habitat_validation.md)), #282 (`default_tuned`); spawned knowledge#28 (habitat weights) · **Produced by:** `data-raw/query_habitat_thresholds_obs.R`, `data-raw/query_habitat_thresholds_fiss.R` → `data-raw/logs/habitat_thresholds_284/`; step 5 by `data-raw/habitat_variants_build.R` and `data-raw/habitat_variants_score.R` → `data-raw/logs/habitat_score_284/`; literature review archived with #284's PWF (`literature.md`) · **Status:** BT `rear_gradient_max` 0.1349 **scored and held**; every other row unscored ## Verdict @@ -12,7 +12,7 @@ | CH | `rear_channel_width_min` | 1.5 | **keep** | medium | | CH | `spawn_gradient_min` | 0 | **keep** | high | | BT | `spawn_gradient_max` | 0.0549 | **keep** | medium | -| BT | `rear_gradient_max` | 0.1049 | **0.1349** | high | +| BT | `rear_gradient_max` | 0.1049 | **0.1349**, scored on held-out WSGs (step 5) | high | | BT | `spawn_channel_width_min` | 2 | **keep** | medium | | BT | `rear_channel_width_min` | 1.5 | **keep** | medium | | BT | `spawn_gradient_min` | 0 | **keep** | medium | @@ -23,8 +23,10 @@ argued against was vetoed by the literature. `spawn_gradient_min` and `cluster_bridge_gradient` live in `parameters_fresh.csv`; both are kept, so `default_tuned` still inherits that file from `default`. -"Unscored" means the candidates have not yet been run against the observation -validation (#283). Scoring can overturn any row, including a "keep". +"Unscored" means the row has not been run against the observation validation (#283). +Step 5 scored the one moved value, BT `rear_gradient_max`, and it held. The CH rows +could not be scored with the data available (Step 5, "Why BT only"). The other BT rows +were not tested. ## Method @@ -350,3 +352,56 @@ The questions scoring must answer: downstream bridge decides whether it survives. 3. Whether spawning capture at 3–4.5 % justifies keeping the CH cutoff above the literature's 3 %. Unscorable: 0 held-out spawn-staged locations in that window. + +### Results, 2026-09-29 + +Run `20260930_014921-53610765`, link @ `a11a001` (build) and `031c5cc` (score). The 23-WSG +closure was modelled clean; each variant differs from `default` in one cell, on one +shared segmentation. Evidence: `data-raw/logs/habitat_score_284/` (`verdict.csv`, +`bands_pooled.csv`, `taper.csv`, `elevation*.csv`, `bridge_band.csv`, `built.csv`, +`stamp_*.txt`). + +**Verdict: BT `rear_gradient_max` 0.1349 holds.** Held-out WSGs, pooled; the core is +18.1 locations per 100 km. + +| step | band km | found | expected at the core rate | ratio | elevation-adjusted | rule | expected-count floor | +|---|---|---|---|---|---|---|---| +| 0.1049 → 0.1249 | 422 | 46 | 76 | 0.60 | 0.75 | take | take | +| 0.1249 → 0.1349 | 163 | 21 | 29 | 0.71 | 0.89 | take | take | +| 0.1349 → 0.1449 | 138 | 8 | 25 | 0.32 | 0.40 | keep (n < 10) | refuse | + +- **Both steps to 0.1349 are taken, and the step past it is not.** Under the rule as fixed + it is underpowered, which leaves 0.1349 standing. Under the alternative floor + (discussed with the operator after the build; see below) it is refused, which also + gives 0.1349. `default_tuned` does not change. +- **Capture against cost** (held out, all stages): stream-rearing capture goes from + 81.2 % under `default` to 84.2 % at 0.1349 (1,841 → 1,908 of 2,266 locations) for + 585 km more rearing (+5.7 %). 0.1449 adds 138 km for 8 more. +- **In-sample WSGs agree** (ratios 0.89, 0.70, 0.65; elevation-adjusted 0.94, 0.75, + 0.69), and never decide. +- **The core itself tapers** with gradient: 18.6, 19.8, 15.6 and 11.8 locations per + 100 km at ≤ 2, 2–5, 5–8 and 8–10.5 %. A cutoff is one line across a slope, not a + cliff the fish see (knowledge#28 takes up weights instead of cutoffs). +- **Elevation is a confound.** Core rearing thins from 24.6 to 19.3 to 10.2 per 100 km + across the low, mid and high thirds of each WSG's own rearing, and the steep bands + sit mostly high (263 of the first band's 422 km). The elevation-adjusted ratio + compares each band with the core at its own elevation mix. It raises the first two + steps, and the third stays low. +- **Question 2 (the bridge).** Of the first band's 422 km, 140 km has spawning upstream + and 282 km (67 %) survives only through the 5 % downstream bridge. The later bands + are 70 % and 74 % bridge-only. 101 km of the first band lies outside its gradient + window: lower-gradient stream the looser cutoff connects to a spawning cluster. +- **Clustering moves a little habitat the other way.** Loosening removed 1.1 km of + rearing (BULK, KOTL, LILL; 0.07 km held out) while adding 1,365 km, when a newly + admitted segment merges clusters. +- **Absences** do not reach these WSGs: the FISS snapshots cover none of the twelve. + +**The floor, discussed after the build (2026-09-29).** The rule's floor is on the +locations *found* in a band. A band fish avoid produces few, so it reads as +"underpowered", not "refuse". The rule can confirm a loosening but hardly ever reject +one, which is backwards for a sparse species. The alternative floor is on the locations +the band would hold at the core's rate (band km × core rate), which is set by the band's +length before any fish are counted. Both are in `verdict.csv` (`decision`, +`decision_expected_floor`). They agree on every step that decides the value, so the +choice did not need making here. It is open for the next tuning. + diff --git a/research/habitat_validation.md b/research/habitat_validation.md index d10d8466..a7a87eb0 100644 --- a/research/habitat_validation.md +++ b/research/habitat_validation.md @@ -1,6 +1,6 @@ # Habitat validation against fish observations -**Verified:** 2026-09-27 · **Issues:** #283 (this), #284 (step 5 scores with it), #290 (pooling as data), #203 (full-key joins), fresh#218 · **Produced by:** `lnk_habitat_validate()` via `data-raw/habitat_validate.R` → `data-raw/logs/habitat_validate_283/` (link @ `0c19e0a`) · **Status:** baseline only; `default_tuned` not yet scored +**Verified:** 2026-09-27 · **Issues:** #283 (this), #284 (step 5 scores with it), #290 (pooling as data), #203 (full-key joins), fresh#218 · **Produced by:** `lnk_habitat_validate()` via `data-raw/habitat_validate.R` → `data-raw/logs/habitat_validate_283/` (link @ `0c19e0a`) · **Status:** baseline; #284 step 5 scored BT `rear_gradient_max` with it (see below) ## What it measures @@ -136,18 +136,17 @@ code path. 508bf44, same database); the CH rows are unchanged, byte for byte. - [`species_pooling.md`](species_pooling.md) has the scenarios. -## Using it for #284 step 5 +## How #284 step 5 used it -Model `default_tuned` into its own schema (`fresh_default_tuned`), stating the run -decisions at launch. Then run: +Step 5 did not diff two independently built schemas: two full runs differ by a segment +(the PSCIS tie), which would break a segment-level comparison. Instead: +- `data-raw/habitat_variants_build.R` prepares each WSG once under `default` and + re-classifies it per threshold variant, into `score284_`. +- `data-raw/habitat_variants_score.R` runs this validator on every variant schema. +- It then scores each threshold step with `lnk_habitat_validate_band()`: locations per + km on the segments the step moves, against the core every step agrees on. - Rscript data-raw/habitat_validate.R \ - --bundles=default:fresh_default,default_tuned:fresh_default_tuned --wsgs=... - -- Read `share_rearing_any` against `rearing_km` for BT on the rear stage. -- Read `share_*_outside_uhc` for CH. -- Hold out records for the in-sample BT value (point 3 above). - -`diff.csv` gives the per-WSG deltas. It is per WSG × species × stage, so step 5's -question 2 (how much newly admitted BT rearing sits above spawning) still needs a -segment-level diff. +Held-out WSGs, not held-out records, answered point 3: none of the eight decide-WSGs +were among the 55 the percentile came from. The results are in +[`habitat_thresholds.md`](habitat_thresholds.md), "Step 5"; the evidence is in +`data-raw/logs/habitat_score_284/`. From 593cd1a733d9ff2ef00ef38f1a277cd056475c4a Mon Sep 17 00:00:00 2001 From: almac2022 Date: Tue, 29 Sep 2026 22:11:53 -0700 Subject: [PATCH 09/11] Archive planning files for issue #284 step 5 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- CLAUDE.md | 2 +- .../2026-09-issue-284-step5-scoring/README.md | 42 +++++++++++++++++++ .../findings.md | 0 .../progress.md | 0 .../review-enumeration.md | 0 .../review-plan.md | 0 .../review-round1.md | 0 .../review-round2.md | 0 .../review-round3.md | 0 .../review-round4.md | 0 .../review-round5.md | 0 .../task_plan.md | 0 12 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 planning/archive/2026-09-issue-284-step5-scoring/README.md rename planning/{active => archive/2026-09-issue-284-step5-scoring}/findings.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/progress.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-enumeration.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-plan.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-round1.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-round2.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-round3.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-round4.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/review-round5.md (100%) rename planning/{active => archive/2026-09-issue-284-step5-scoring}/task_plan.md (100%) diff --git a/CLAUDE.md b/CLAUDE.md index 6b6668dc..5363b22b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -37,7 +37,7 @@ Experimental package — breaking all the time and loving the learning curve. St agreed here, and the choice is open. - **Resume trusts nothing it cannot prove.** A base WSG is reused only when its log row is clean at this HEAD and its digest sits in the same `--out`; `built.csv` is per - variant × WSG. Code-check took five rounds to get there (`planning/archive/…-284-*`). + variant × WSG. Code-check took five rounds to get there (`planning/archive/2026-09-issue-284-step5-scoring/`). - Loosening a rearing cutoff can **remove** a little rearing (1.1 km against 1,365 km): clusters merge. diff --git a/planning/archive/2026-09-issue-284-step5-scoring/README.md b/planning/archive/2026-09-issue-284-step5-scoring/README.md new file mode 100644 index 00000000..3a2f4079 --- /dev/null +++ b/planning/archive/2026-09-issue-284-step5-scoring/README.md @@ -0,0 +1,42 @@ +## Outcome + +#284 step 5 scored the one moved threshold, BT `rear_gradient_max` 0.1349 in `default_tuned`, against fish observations on eight watershed groups held out from its calibration. It held. Two scripts do the work: +- `data-raw/habitat_variants_build.R` models a drainage closure once under `default` and re-classifies each threshold variant on that shared segmentation. +- `data-raw/habitat_variants_score.R` validates every variant schema and scores each ladder step with the new exported `lnk_habitat_validate_band()`: locations per km on the segments a step moves, against the core every step agrees on. + +Along the way: +- The FISS absence taxa became data, with the #283 outputs reproduced byte for byte. +- A counts-only power check reshaped the design before any band was seen: BT only, a widened held-out set, CH dropped as unscorable. +- A discussion with the operator added the taper, an elevation split, an elevation-adjusted ratio and an expected-count floor. It also spun out knowledge#28: weights instead of cutoffs, biology first. + +## Measurement + +Held out, core 18.1 locations per 100 km. + +| step | found | expected at the core rate | ratio | elevation-adjusted | +|---|---|---|---|---| +| to 0.1249 | 46 | 76 | 0.60 | 0.75 | +| to 0.1349 | 21 | 29 | 0.71 | 0.89 | +| to 0.1449 | 8 | 25 | 0.32 | 0.40 | + +- 0.1349 holds under both the rule's floor and the expected-count floor, so `default_tuned` is unchanged. +- Capture rises from 81.2 % to 84.2 % for +585 km (+5.7 %). +- The core tapers with gradient (18.6 / 19.8 / 15.6 / 11.8 per 100 km) and with elevation (24.6 / 19.3 / 10.2). The steep bands sit high, which is why the adjusted ratio exists. +- 67–74 % of each band is bridge-only rearing; 101 km of the first band lies outside its gradient window (connectivity-admitted). +- The build ran in 139.6 min (23 WSGs, 4 schemas). + +**Wrong turns, kept on purpose:** +- The planned held-out set could decide one step in six (BT 10 / 1 / 0, CH 0 / 1 / 2 locations). The power check found it; the plan review flagged it. +- The first power probe used `DISTINCT ON` and moved staged counts by one between runs. +- The build's first access invariant could never pass. The BULL pre-flight hit it at run time; round 1 of the review had predicted it. +- The walk first treated an underpowered step as a refusal, then walked per row rather than per ladder. +- The nesting guard stopped the full score on 1.1 km of clustering noise. +- Code-check took five rounds and an enumeration. Rounds 3–5 each found a defect inside the previous fix; the mechanism was a partial producer read by a whole-population reader (`review-round*.md`, `review-enumeration.md`). + +Durable verdict: [`research/habitat_thresholds.md`](../../../research/habitat_thresholds.md), "Step 5". + +## Evidence + +`data-raw/logs/habitat_score_284/*` (run `20260930_014921-53610765`; `power_windows.*` from before the build). + +Closed by: PR (this branch) — closes #284 diff --git a/planning/active/findings.md b/planning/archive/2026-09-issue-284-step5-scoring/findings.md similarity index 100% rename from planning/active/findings.md rename to planning/archive/2026-09-issue-284-step5-scoring/findings.md diff --git a/planning/active/progress.md b/planning/archive/2026-09-issue-284-step5-scoring/progress.md similarity index 100% rename from planning/active/progress.md rename to planning/archive/2026-09-issue-284-step5-scoring/progress.md diff --git a/planning/active/review-enumeration.md b/planning/archive/2026-09-issue-284-step5-scoring/review-enumeration.md similarity index 100% rename from planning/active/review-enumeration.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-enumeration.md diff --git a/planning/active/review-plan.md b/planning/archive/2026-09-issue-284-step5-scoring/review-plan.md similarity index 100% rename from planning/active/review-plan.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-plan.md diff --git a/planning/active/review-round1.md b/planning/archive/2026-09-issue-284-step5-scoring/review-round1.md similarity index 100% rename from planning/active/review-round1.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-round1.md diff --git a/planning/active/review-round2.md b/planning/archive/2026-09-issue-284-step5-scoring/review-round2.md similarity index 100% rename from planning/active/review-round2.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-round2.md diff --git a/planning/active/review-round3.md b/planning/archive/2026-09-issue-284-step5-scoring/review-round3.md similarity index 100% rename from planning/active/review-round3.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-round3.md diff --git a/planning/active/review-round4.md b/planning/archive/2026-09-issue-284-step5-scoring/review-round4.md similarity index 100% rename from planning/active/review-round4.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-round4.md diff --git a/planning/active/review-round5.md b/planning/archive/2026-09-issue-284-step5-scoring/review-round5.md similarity index 100% rename from planning/active/review-round5.md rename to planning/archive/2026-09-issue-284-step5-scoring/review-round5.md diff --git a/planning/active/task_plan.md b/planning/archive/2026-09-issue-284-step5-scoring/task_plan.md similarity index 100% rename from planning/active/task_plan.md rename to planning/archive/2026-09-issue-284-step5-scoring/task_plan.md From 002321fbb0413eba44bd7ddd4bf1cea4112d800c Mon Sep 17 00:00:00 2001 From: almac2022 Date: Wed, 30 Sep 2026 09:56:02 -0700 Subject: [PATCH 10/11] Score: per-WSG habitat change against the base (#284) habitat_change.csv gives, per variant x WSG, stream-rearing and spawning km against the base and the change in km and %, so 'how much habitat does the cutoff add' is a produced number rather than a hand query of summary.csv. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- data-raw/habitat_variants_score.R | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/data-raw/habitat_variants_score.R b/data-raw/habitat_variants_score.R index 906ff1b7..725258c1 100644 --- a/data-raw/habitat_variants_score.R +++ b/data-raw/habitat_variants_score.R @@ -44,6 +44,8 @@ # band's low rate can be told apart from "it is higher up" # elevation_adjusted.csv per band: found / expected at the core's rate in # the band's own elevation mix +# habitat_change.csv per variant x WSG: stream-rearing and spawning km +# against the base, and the change (km and %) # stamp_score.txt environment stamp suppressPackageStartupMessages({ @@ -116,7 +118,8 @@ species <- sort(unique(roles$species_code)) schema_of <- function(v) paste0(prefix, v) outputs <- c("summary.csv", "totals.csv", "bands.csv", "bands_pooled.csv", "verdict.csv", "bridge_band.csv", "taper.csv", "elevation.csv", - "elevation_adjusted.csv", "stamp_score.txt") + "elevation_adjusted.csv", "habitat_change.csv", + "stamp_score.txt") unlink(file.path(dir_out, outputs)) # Taken at launch: the code that runs is the code at the start. @@ -281,6 +284,27 @@ totals <- totals[do.call(order, totals[rev(key_t)]), ] utils::write.csv(totals, file.path(dir_out, "totals.csv"), row.names = FALSE, na = "") +# What each variant does to the amount of habitat, WSG by WSG: the cost side +# of the score, in the units people quote (km), from the rollup the +# validator already carries. One row per variant x WSG x species. +hc <- summary[summary$buffer_m == 0 & summary$stage == "any", + c("variant", "watershed_group_code", "species_code", "role", + "rearing_km", "spawning_km")] +hc_base <- hc[hc$variant == base_variant, ] +key_hc <- function(d) paste(d$watershed_group_code, d$species_code) +hc <- hc[hc$variant != base_variant, ] +i <- match(key_hc(hc), key_hc(hc_base)) +hc$rearing_km_base <- hc_base$rearing_km[i] +hc$spawning_km_base <- hc_base$spawning_km[i] +hc$rearing_km_added <- hc$rearing_km - hc$rearing_km_base +hc$rearing_pct_added <- ifelse(hc$rearing_km_base > 0, + 100 * hc$rearing_km_added / hc$rearing_km_base, + NA_real_) +hc$spawning_km_added <- hc$spawning_km - hc$spawning_km_base +hc <- hc[order(hc$variant, -hc$rearing_pct_added), ] +utils::write.csv(hc, file.path(dir_out, "habitat_change.csv"), + row.names = FALSE, na = "") + # -- absence sites attached to segments --------------------------------------------------- # The validator's absence output is counts; to count absence sites in a band # they are attached the way observations are, by running them through the From 3a5c0bb2d688df00e137ef22a485a9713a28e30a Mon Sep 17 00:00:00 2001 From: almac2022 Date: Wed, 30 Sep 2026 10:09:00 -0700 Subject: [PATCH 11/11] Step 5 docs: plain-language summary and per-WSG habitat change (#284) research/habitat_thresholds.md gains a plain-terms summary and the per-WSG table from habitat_change.csv: 0.1349 adds 1,105 km of BT rearing (+5.8 %) across the 12 WSGs, 2 % (BABL) to 9 % (KOTL, UARL). It also gains the combined elevation share: 366 of the 585 km the steps add sit in the high third. The re-run's outputs differ from the last only in trailing digits (Postgres float summation order, as #293). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WJE2szSCkeV9R3qKhuSwyx --- CLAUDE.md | 4 +- data-raw/logs/habitat_score_284/bands.csv | 82 +++++++++---------- .../logs/habitat_score_284/bands_pooled.csv | 8 +- .../logs/habitat_score_284/bridge_band.csv | 16 ++-- data-raw/logs/habitat_score_284/elevation.csv | 6 +- .../logs/habitat_score_284/habitat_change.csv | 37 +++++++++ .../logs/habitat_score_284/stamp_score.txt | 6 +- data-raw/logs/habitat_score_284/taper.csv | 12 +-- .../2026-09-issue-284-step5-scoring/README.md | 2 +- research/habitat_thresholds.md | 41 +++++++++- 10 files changed, 146 insertions(+), 68 deletions(-) create mode 100644 data-raw/logs/habitat_score_284/habitat_change.csv diff --git a/CLAUDE.md b/CLAUDE.md index 5363b22b..e235a935 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -28,7 +28,9 @@ Experimental package — breaking all the time and loving the learning curve. St could decide one step in six (`data-raw/logs/habitat_score_284/power_windows.*`). BT was widened to eight held-out WSGs, and CH dropped: unscorable, spread thin. - **Result.** Steps to 0.1349 take (ratio 0.60 and 0.71; 0.75 and 0.89 - elevation-adjusted). 0.1449 does not (8 found, 25 expected). + elevation-adjusted). 0.1449 does not (8 found, 25 expected). The change adds + 1,105 km of BT rearing (+5.8 %) across the 12 WSGs, from 2 % (BABL) to 9 % (KOTL, + UARL); `habitat_change.csv`. - **Elevation confounds gradient.** Core BT rearing thins 24.6 → 10.2 per 100 km from the low to the high third, and steep bands sit high. Weights instead of cutoffs went to knowledge#28, the biology first. diff --git a/data-raw/logs/habitat_score_284/bands.csv b/data-raw/logs/habitat_score_284/bands.csv index ada2f162..21e84fd3 100644 --- a/data-raw/logs/habitat_score_284/bands.csv +++ b/data-raw/logs/habitat_score_284/bands.csv @@ -79,22 +79,22 @@ "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","removed","rearing","any",0,0,3009.80851308213,338,,0.112299502952059,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","added","rearing","any",29.3769243400633,0,1062.04039165997,64,0,0.060261361528791,0,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","any",0,0,1062.04039165997,64,,0.060261361528791,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","any",15.1338064085111,2,988.113654830613,75,0.132154459097297,0.0759021997452882,1.74111500774391,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830613,75,,0.0759021997452882,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","any",40.4349169761764,0,2122.70865932044,563,0,0.265227165078903,0,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078903,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","any",35.4085601703188,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","any",0.298000000000023,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","any",16.2329947693528,3,906.052043482134,368,0.184808782521379,0.40615768448102,0.455017323524295,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","any",0,0,906.052043482134,368,,0.40615768448102,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","any",28.8705363433332,5,1692.09746836156,259,0.173186945352839,0.153064468709824,1.13146406094522,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","any",15.1338064085111,2,988.113654830613,75,0.132154459097297,0.0759021997452883,1.74111500774391,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830613,75,,0.0759021997452883,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","any",40.4349169761764,0,2122.70865932044,563,0,0.265227165078904,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078904,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","any",35.4085601703188,0,1599.0204217732,164,0,0.102562792674114,0,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","any",0.298000000000023,0,1599.0204217732,164,0,0.102562792674114,0,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","any",16.2329947693528,3,906.052043482133,368,0.184808782521379,0.40615768448102,0.455017323524294,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","any",0,0,906.052043482133,368,,0.40615768448102,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","any",28.8705363433331,5,1692.09746836156,259,0.173186945352839,0.153064468709824,1.13146406094522,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","any",0,0,1692.09746836156,259,,0.153064468709824,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","any",35.3697425932225,1,2634.98859228862,259,0.0282727531127585,0.0982926456524223,0.28763854024985,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","any",35.3697425932226,1,2634.98859228862,259,0.0282727531127585,0.0982926456524223,0.28763854024985,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","any",0,0,2634.98859228862,259,,0.0982926456524223,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","any",9.0739434693417,2,561.14428404833,240,0.220411335684142,0.427697486764971,0.515344004827558,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","any",0,0,561.14428404833,240,,0.427697486764971,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","any",21.4460865658432,5,776.924742494946,163,0.233142768712097,0.209801530424371,1.11125389905647,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494946,163,,0.209801530424371,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","any",21.4460865658433,5,776.924742494945,163,0.233142768712097,0.209801530424371,1.11125389905647,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494945,163,,0.209801530424371,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","spawn",9.67702491184096,0,2055.07648874055,1,0,0.000486599893229692,0,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","removed","rearing","spawn",0,0,2055.07648874055,1,,0.000486599893229692,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","added","rearing","spawn",21.665527749263,0,1723.88438335523,4,0,0.0023203412239368,0,,"held_out" @@ -103,23 +103,23 @@ "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULK","BT","removed","rearing","spawn",0,0,3009.80851308213,9,,0.0029902234513862,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","added","rearing","spawn",29.3769243400633,0,1062.04039165997,0,0,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","spawn",0,0,1062.04039165997,0,,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","spawn",15.1338064085111,0,988.113654830612,0,0,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","spawn",0,0,988.113654830612,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","spawn",15.1338064085111,0,988.113654830613,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","spawn",0,0,988.113654830613,0,,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","spawn",40.4349169761764,0,2122.70865932044,0,0,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","spawn",0,0,2122.70865932044,0,,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","spawn",35.4085601703188,0,1599.0204217732,0,0,0,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","spawn",0.298000000000023,0,1599.0204217732,0,0,0,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","spawn",16.2329947693528,0,906.052043482134,6,0,0.00662213616001663,0,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","spawn",0,0,906.052043482134,6,,0.00662213616001663,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","spawn",28.8705363433332,1,1692.09746836156,15,0.0346373890705679,0.008864737570067,3.90732255713082,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","spawn",16.2329947693528,0,906.052043482133,6,0,0.00662213616001664,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","spawn",0,0,906.052043482133,6,,0.00662213616001664,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","spawn",28.8705363433331,1,1692.09746836156,15,0.0346373890705679,0.008864737570067,3.90732255713082,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","spawn",0,0,1692.09746836156,15,,0.008864737570067,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","spawn",35.3697425932226,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","spawn",35.3697425932225,0,2634.98859228862,0,0,0,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","spawn",0,0,2634.98859228862,0,,0,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","spawn",9.0739434693417,0,561.144284048331,0,0,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.144284048331,0,,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","spawn",21.4460865658432,0,776.924742494946,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","spawn",9.0739434693417,0,561.14428404833,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.14428404833,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","added","rearing","spawn",21.4460865658433,0,776.924742494946,0,0,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","UARL","BT","removed","rearing","spawn",0,0,776.924742494946,0,,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","rear",9.67702491184096,4,2055.07648874055,85,0.413350181118738,0.0413609909245238,9.99372045686783,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","added","rearing","rear",9.67702491184096,4,2055.07648874055,85,0.413350181118738,0.0413609909245238,9.99372045686782,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABL","BT","removed","rearing","rear",0,0,2055.07648874055,85,,0.0413609909245238,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","added","rearing","rear",21.665527749263,3,1723.88438335523,148,0.138468817132879,0.0858526252856615,1.61286642862865,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BABR","BT","removed","rearing","rear",0,0,1723.88438335523,148,,0.0858526252856615,,,"held_out" @@ -129,15 +129,15 @@ "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BULL","BT","removed","rearing","rear",0,0,1062.04039165997,0,,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","added","rearing","rear",15.1338064085111,0,988.113654830612,0,0,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","CLRH","BT","removed","rearing","rear",0,0,988.113654830612,0,,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","rear",40.4349169761764,0,2122.70865932044,0,0,0,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932044,0,,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","added","rearing","rear",40.4349169761763,0,2122.70865932043,0,0,0,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932043,0,,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","added","rearing","rear",35.4085601703188,0,1599.0204217732,0,0,0,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","KOTL","BT","removed","rearing","rear",0.298000000000023,0,1599.0204217732,0,0,0,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","rear",16.2329947693528,0,906.052043482134,8,0,0.00882951488002217,0,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","rear",0,0,906.052043482134,8,,0.00882951488002217,,,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","rear",28.8705363433332,3,1692.09746836156,63,0.103912167211704,0.0372318977942814,2.79094468366487,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942814,,,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","rear",35.3697425932225,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","added","rearing","rear",16.2329947693528,0,906.052043482134,8,0,0.00882951488002218,0,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","LILL","BT","removed","rearing","rear",0,0,906.052043482134,8,,0.00882951488002218,,,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","added","rearing","rear",28.8705363433331,3,1692.09746836156,63,0.103912167211704,0.0372318977942815,2.79094468366487,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942815,,,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","added","rearing","rear",35.3697425932226,0,2634.98859228862,0,0,0,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","PARS","BT","removed","rearing","rear",0,0,2634.98859228862,0,,0,,,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","added","rearing","rear",9.0739434693417,0,561.14428404833,0,0,0,,,"held_out" "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","REVL","BT","removed","rearing","rear",0,0,561.14428404833,0,,0,,,"held_out" @@ -147,12 +147,12 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","removed","rearing","any",0,0,2055.07648874055,105,,0.0510929887891176,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","any",12.6344733026478,0,1723.88438335523,263,0,0.152562435473844,0,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","any",0,0,1723.88438335523,263,,0.152562435473844,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","any",44.725705986597,4,3009.80851308213,338,0.0894340270715611,0.112299502952059,0.796388449820126,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","any",44.725705986597,4,3009.80851308213,338,0.0894340270715612,0.112299502952059,0.796388449820125,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","any",0,0,3009.80851308213,338,,0.112299502952059,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","added","rearing","any",17.6929224260818,0,1062.04039165997,64,0,0.060261361528791,0,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","any",0,0,1062.04039165997,64,,0.060261361528791,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","any",15.5179615510741,0,988.113654830612,75,0,0.0759021997452883,0,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830612,75,,0.0759021997452883,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","any",15.5179615510741,0,988.113654830611,75,0,0.0759021997452884,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","any",0,0,988.113654830611,75,,0.0759021997452884,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","any",47.2946196566879,2,2122.70865932044,563,0.0422881083412452,0.265227165078904,0.15944109016384,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","any",0,0,2122.70865932044,563,,0.265227165078904,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","added","rearing","any",36.823799566551,0,1599.0204217732,164,0,0.102562792674115,0,,"in_sample" @@ -169,10 +169,10 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","removed","rearing","any",0,0,776.924742494946,163,,0.209801530424371,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","added","rearing","spawn",7.74047832366764,0,2055.07648874055,1,0,0.000486599893229692,0,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABL","BT","removed","rearing","spawn",0,0,2055.07648874055,1,,0.000486599893229692,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","spawn",12.6344733026478,0,1723.88438335523,4,0,0.0023203412239368,0,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","spawn",0,0,1723.88438335523,4,,0.0023203412239368,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","spawn",44.725705986597,0,3009.80851308213,9,0,0.00299022345138619,0,,"in_sample" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","spawn",0,0,3009.80851308213,9,,0.00299022345138619,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","added","rearing","spawn",12.6344733026478,0,1723.88438335523,4,0,0.00232034122393679,0,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BABR","BT","removed","rearing","spawn",0,0,1723.88438335523,4,,0.00232034122393679,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","added","rearing","spawn",44.725705986597,0,3009.80851308213,9,0,0.0029902234513862,0,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULK","BT","removed","rearing","spawn",0,0,3009.80851308213,9,,0.0029902234513862,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","added","rearing","spawn",17.6929224260818,0,1062.04039165997,0,0,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","spawn",0,0,1062.04039165997,0,,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","spawn",15.5179615510741,0,988.113654830612,0,0,0,,,"held_out" @@ -185,7 +185,7 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","removed","rearing","spawn",0,0,906.052043482134,6,,0.00662213616001663,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","added","rearing","spawn",16.4592075009036,0,1692.09746836156,15,0,0.008864737570067,0,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","removed","rearing","spawn",0,0,1692.09746836156,15,,0.008864737570067,,,"in_sample" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","spawn",23.7460202217577,0,2634.98859228862,0,0,0,,,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","spawn",23.7460202217576,0,2634.98859228862,0,0,0,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","removed","rearing","spawn",0,0,2634.98859228862,0,,0,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","spawn",11.9599072358722,0,561.14428404833,0,0,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","spawn",0,0,561.14428404833,0,,0,,,"held_out" @@ -201,8 +201,8 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BULL","BT","removed","rearing","rear",0,0,1062.04039165997,0,,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","added","rearing","rear",15.5179615510741,0,988.113654830613,0,0,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","CLRH","BT","removed","rearing","rear",0,0,988.113654830613,0,,0,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","rear",47.2946196566879,0,2122.70865932043,0,0,0,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932043,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","added","rearing","rear",47.2946196566879,0,2122.70865932044,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","ELKR","BT","removed","rearing","rear",0,0,2122.70865932044,0,,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","added","rearing","rear",36.823799566551,0,1599.0204217732,0,0,0,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","KOTL","BT","removed","rearing","rear",0,0,1599.0204217732,0,,0,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","LILL","BT","added","rearing","rear",10.0037762114398,0,906.052043482134,8,0,0.00882951488002217,0,,"held_out" @@ -211,7 +211,7 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","MORR","BT","removed","rearing","rear",0,0,1692.09746836156,63,,0.0372318977942814,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","added","rearing","rear",23.7460202217577,0,2634.98859228862,0,0,0,,,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","PARS","BT","removed","rearing","rear",0,0,2634.98859228862,0,,0,,,"in_sample" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","rear",11.9599072358722,0,561.14428404833,0,0,0,,,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","rear",0,0,561.14428404833,0,,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","added","rearing","rear",11.9599072358722,0,561.144284048331,0,0,0,,,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","REVL","BT","removed","rearing","rear",0,0,561.144284048331,0,,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","added","rearing","rear",14.6654583060648,0,776.924742494946,0,0,0,,,"held_out" "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","UARL","BT","removed","rearing","rear",0,0,776.924742494946,0,,0,,,"held_out" diff --git a/data-raw/logs/habitat_score_284/bands_pooled.csv b/data-raw/logs/habitat_score_284/bands_pooled.csv index add20b8c..3ba3d7d3 100644 --- a/data-raw/logs/habitat_score_284/bands_pooled.csv +++ b/data-raw/logs/habitat_score_284/bands_pooled.csv @@ -18,7 +18,7 @@ "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","removed","rear",0,0,10195.9446479322,241,,0.0236368486022407, "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","held_out","removed","spawn",0,0,10195.9446479322,11,,0.00107886030964584, "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","any",137.577626542057,11,8935.91499550551,1020,0.0799548609499912,0.114146117159018,0.700460628359396 -"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","rear",137.577626542057,7,8935.91499550551,224,0.0508803660590853,0.0250673825917844,2.02974386626871 +"bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","rear",137.577626542057,7,8935.91499550551,224,0.0508803660590853,0.0250673825917844,2.0297438662687 "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","added","spawn",137.577626542057,1,8935.91499550551,24,0.00726862372272647,0.0026857909919769,2.70632515502494 "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","removed","any",0.298000000000023,0,8935.91499550551,1020,0,0.114146117159018,0 "bt_rear_0p1349","bt_rear_0p1249","rear_gradient_max",0.1249,0.1349,"added","any","BT","rearing","in_sample","removed","rear",0.298000000000023,0,8935.91499550551,224,0,0.0250673825917844,0 @@ -29,9 +29,9 @@ "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","any",0,0,10195.9446479322,1841,,0.180561984550727, "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","rear",0,0,10195.9446479322,241,,0.0236368486022407, "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","held_out","removed","spawn",0,0,10195.9446479322,11,,0.00107886030964584, -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","any",121.754733275809,9,8935.91499550551,1020,0.0739190974991702,0.114146117159018,0.64758310960497 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","any",121.754733275809,9,8935.91499550551,1020,0.0739190974991702,0.114146117159018,0.647583109604969 "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","rear",121.754733275809,2,8935.91499550551,224,0.0164264661109267,0.0250673825917844,0.655292432338362 -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","spawn",121.754733275809,0,8935.91499550552,24,0,0.0026857909919769,0 +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","added","spawn",121.754733275809,0,8935.91499550551,24,0,0.0026857909919769,0 "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","any",0,0,8935.91499550551,1020,,0.114146117159018, "bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","rear",0,0,8935.91499550551,224,,0.0250673825917844, -"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","spawn",0,0,8935.91499550552,24,,0.0026857909919769, +"bt_rear_0p1449","bt_rear_0p1349","rear_gradient_max",0.1349,0.1449,"added","any","BT","rearing","in_sample","removed","spawn",0,0,8935.91499550551,24,,0.0026857909919769, diff --git a/data-raw/logs/habitat_score_284/bridge_band.csv b/data-raw/logs/habitat_score_284/bridge_band.csv index caf45120..e0cf2a40 100644 --- a/data-raw/logs/habitat_score_284/bridge_band.csv +++ b/data-raw/logs/habitat_score_284/bridge_band.csv @@ -3,10 +3,10 @@ "bt_rear_0p1249","default","BT","BABL",FALSE,TRUE,10.670711929456,"held_out" "bt_rear_0p1249","default","BT","BABL",TRUE,TRUE,7.23612431523042,"held_out" "bt_rear_0p1249","default","BT","BABR",FALSE,FALSE,26.5230881513177,"held_out" -"bt_rear_0p1249","default","BT","BABR",FALSE,TRUE,21.8782963685213,"held_out" -"bt_rear_0p1249","default","BT","BABR",TRUE,TRUE,12.2213425303866,"held_out" +"bt_rear_0p1249","default","BT","BABR",FALSE,TRUE,21.8782963685214,"held_out" +"bt_rear_0p1249","default","BT","BABR",TRUE,TRUE,12.2213425303867,"held_out" "bt_rear_0p1249","default","BT","BULK",FALSE,FALSE,44.8996679483216,"in_sample" -"bt_rear_0p1249","default","BT","BULK",FALSE,TRUE,50.0429114624976,"in_sample" +"bt_rear_0p1249","default","BT","BULK",FALSE,TRUE,50.0429114624975,"in_sample" "bt_rear_0p1249","default","BT","BULK",TRUE,TRUE,26.2788163072244,"in_sample" "bt_rear_0p1249","default","BT","BULL",FALSE,FALSE,20.7829834590131,"held_out" "bt_rear_0p1249","default","BT","BULL",FALSE,TRUE,26.3489253442464,"held_out" @@ -49,7 +49,7 @@ "bt_rear_0p1349","bt_rear_0p1249","BT","BULL",FALSE,TRUE,12.2220200256773,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","BULL",TRUE,TRUE,4.28440041785419,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",FALSE,FALSE,2.43601931213392,"held_out" -"bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",FALSE,TRUE,4.68317506763157,"held_out" +"bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",FALSE,TRUE,4.68317506763158,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","CLRH",TRUE,TRUE,8.01461202874563,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","ELKR",FALSE,FALSE,16.7025648404777,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","ELKR",FALSE,TRUE,16.926783235467,"held_out" @@ -61,7 +61,7 @@ "bt_rear_0p1349","bt_rear_0p1249","BT","LILL",FALSE,TRUE,4.70075485752868,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","LILL",TRUE,TRUE,7.4762230687745,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","MORR",FALSE,FALSE,13.9968743265805,"in_sample" -"bt_rear_0p1349","bt_rear_0p1249","BT","MORR",FALSE,TRUE,11.414724006598,"in_sample" +"bt_rear_0p1349","bt_rear_0p1249","BT","MORR",FALSE,TRUE,11.4147240065981,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","BT","MORR",TRUE,TRUE,3.45893801015461,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","BT","PARS",FALSE,FALSE,14.7751100714056,"in_sample" "bt_rear_0p1349","bt_rear_0p1249","BT","PARS",FALSE,TRUE,15.1916215197573,"in_sample" @@ -72,7 +72,7 @@ "bt_rear_0p1349","bt_rear_0p1249","BT","UARL",FALSE,FALSE,7.9228866970992,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","UARL",FALSE,TRUE,4.61383758918555,"held_out" "bt_rear_0p1349","bt_rear_0p1249","BT","UARL",TRUE,TRUE,8.90936227955849,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","BT","BABL",FALSE,FALSE,3.39815701172267,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","BABL",FALSE,FALSE,3.39815701172266,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","BABL",FALSE,TRUE,3.24123103944117,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","BABL",TRUE,TRUE,1.1010902725038,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","BABR",FALSE,FALSE,5.76995585015026,"held_out" @@ -86,7 +86,7 @@ "bt_rear_0p1449","bt_rear_0p1349","BT","BULL",TRUE,TRUE,2.67497537834193,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",FALSE,FALSE,3.35575956871938,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",FALSE,TRUE,6.29262864947983,"held_out" -"bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",TRUE,TRUE,5.86957333287492,"held_out" +"bt_rear_0p1449","bt_rear_0p1349","BT","CLRH",TRUE,TRUE,5.86957333287493,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",FALSE,FALSE,21.9839821420258,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",FALSE,TRUE,15.8237144901717,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","ELKR",TRUE,TRUE,9.4869230244904,"held_out" @@ -101,7 +101,7 @@ "bt_rear_0p1449","bt_rear_0p1349","BT","MORR",TRUE,TRUE,2.70124796783397,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","BT","PARS",FALSE,FALSE,5.34608698313147,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","BT","PARS",FALSE,TRUE,12.5680183689373,"in_sample" -"bt_rear_0p1449","bt_rear_0p1349","BT","PARS",TRUE,TRUE,5.83191486968893,"in_sample" +"bt_rear_0p1449","bt_rear_0p1349","BT","PARS",TRUE,TRUE,5.83191486968892,"in_sample" "bt_rear_0p1449","bt_rear_0p1349","BT","REVL",FALSE,FALSE,5.68660358409017,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","REVL",FALSE,TRUE,3.01665467418154,"held_out" "bt_rear_0p1449","bt_rear_0p1349","BT","REVL",TRUE,TRUE,3.25664897760048,"held_out" diff --git a/data-raw/logs/habitat_score_284/elevation.csv b/data-raw/logs/habitat_score_284/elevation.csv index 248c771d..97aa9334 100644 --- a/data-raw/logs/habitat_score_284/elevation.csv +++ b/data-raw/logs/habitat_score_284/elevation.csv @@ -2,7 +2,7 @@ "BT","rear_gradient_max","held_out","bt_rear_0p1249","low",65.6767599048235,7,10.6582602584905,24.5596218503652,0.433974933467144 "BT","rear_gradient_max","held_out","bt_rear_0p1249","mid",92.9955260896776,19,20.431090396411,19.3492582250811,1.05591078266389 "BT","rear_gradient_max","held_out","bt_rear_0p1249","high",263.527188067484,20,7.589349754257,10.2319549267572,0.741730178502877 -"BT","rear_gradient_max","held_out","bt_rear_0p1349","low",29.0281747239031,7,24.1145027773169,24.5596218503652,0.981875980185676 +"BT","rear_gradient_max","held_out","bt_rear_0p1349","low",29.0281747239031,7,24.1145027773169,24.5596218503652,0.981875980185677 "BT","rear_gradient_max","held_out","bt_rear_0p1349","mid",31.2042545458181,1,3.20469120174517,19.3492582250811,0.165623465482059 "BT","rear_gradient_max","held_out","bt_rear_0p1349","high",102.808795920671,13,12.6448324616417,10.2319549267572,1.23581784245107 "BT","rear_gradient_max","held_out","bt_rear_0p1449","low",21.734720671654,3,13.8027998855883,24.5596218503652,0.562011905952171 @@ -11,10 +11,10 @@ "BT","rear_gradient_max","held_out","core","low",3403.96120548399,836,24.5596218503652,24.5596218503652,1 "BT","rear_gradient_max","held_out","core","mid",3400.64715838606,658,19.3492582250811,19.3492582250811,1 "BT","rear_gradient_max","held_out","core","high",3391.33628406214,347,10.2319549267572,10.2319549267572,1 -"BT","rear_gradient_max","in_sample","bt_rear_0p1249","low",37.5824512554325,5,13.3040816470886,11.089893103126,1.19965824046928 +"BT","rear_gradient_max","in_sample","bt_rear_0p1249","low",37.5824512554325,5,13.3040816470886,11.089893103126,1.19965824046929 "BT","rear_gradient_max","in_sample","bt_rear_0p1249","mid",92.5980184139586,9,9.71943045235113,13.3171881527,0.729841040083268 "BT","rear_gradient_max","in_sample","bt_rear_0p1249","high",253.456172383029,25,9.86363826335207,9.84009128864476,1.00239296303424 -"BT","rear_gradient_max","in_sample","bt_rear_0p1349","low",10.9412369484126,1,9.13973442596074,11.089893103126,0.824149912083865 +"BT","rear_gradient_max","in_sample","bt_rear_0p1349","low",10.9412369484126,1,9.13973442596074,11.089893103126,0.824149912083866 "BT","rear_gradient_max","in_sample","bt_rear_0p1349","mid",26.3802312628852,6,22.7443040214795,13.3171881527,1.70789086710232 "BT","rear_gradient_max","in_sample","bt_rear_0p1349","high",100.256158330759,4,3.98977984654412,9.84009128864476,0.405461669969285 "BT","rear_gradient_max","in_sample","bt_rear_0p1449","low",11.355259955083,0,0,11.089893103126,0 diff --git a/data-raw/logs/habitat_score_284/habitat_change.csv b/data-raw/logs/habitat_score_284/habitat_change.csv new file mode 100644 index 00000000..3a0ac7b2 --- /dev/null +++ b/data-raw/logs/habitat_score_284/habitat_change.csv @@ -0,0 +1,37 @@ +"variant","watershed_group_code","species_code","role","rearing_km","spawning_km","rearing_km_base","spawning_km_base","rearing_km_added","rearing_pct_added","spawning_km_added" +"bt_rear_0p1249","KOTL","BT","in_sample",1706.74,1035.17,1599.21,1035.17,107.53,6.72394494781798,0 +"bt_rear_0p1249","UARL","BT","held_out",824.07,529.54,776.92,529.54,47.1500000000001,6.06883591618186,0 +"bt_rear_0p1249","ELKR","BT","held_out",2243.09,1536.57,2122.71,1536.57,120.38,5.67105256959265,0 +"bt_rear_0p1249","BULL","BT","held_out",1121.21,715.43,1062.04,715.43,59.1700000000001,5.57135324469889,0 +"bt_rear_0p1249","CLRH","BT","held_out",1033.07,733.49,988.11,733.49,44.9599999999999,4.55010069729078,0 +"bt_rear_0p1249","REVL","BT","held_out",583.68,412.05,561.14,412.05,22.54,4.01682289624692,0 +"bt_rear_0p1249","BULK","BT","in_sample",3131.03,1853.38,3010.32,1853.38,120.71,4.00987270456297,0 +"bt_rear_0p1249","PARS","BT","in_sample",2739.74,1685.39,2634.99,1685.39,104.75,3.97534715501767,0 +"bt_rear_0p1249","LILL","BT","held_out",941.34,670.34,906.12,670.34,35.22,3.88690239703351,0 +"bt_rear_0p1249","BABR","BT","held_out",1784.51,1000.77,1723.88,1000.77,60.6299999999999,3.5170661530965,0 +"bt_rear_0p1249","MORR","BT","in_sample",1741.34,962.09,1692.1,962.09,49.24,2.90999349920218,0 +"bt_rear_0p1249","BABL","BT","held_out",2087.11,1048.06,2055.08,1048.06,32.0300000000002,1.55857679506395,0 +"bt_rear_0p1349","KOTL","BT","in_sample",1741.85,1035.17,1599.21,1035.17,142.64,8.91940395570312,0 +"bt_rear_0p1349","UARL","BT","held_out",845.52,529.54,776.92,529.54,68.6,8.8297379395562,0 +"bt_rear_0p1349","BULL","BT","held_out",1150.59,715.43,1062.04,715.43,88.55,8.33772739256525,0 +"bt_rear_0p1349","ELKR","BT","held_out",2283.52,1536.57,2122.71,1536.57,160.81,7.57569333540615,0 +"bt_rear_0p1349","CLRH","BT","held_out",1048.2,733.49,988.11,733.49,60.09,6.08130673710417,0 +"bt_rear_0p1349","LILL","BT","held_out",957.58,670.34,906.12,670.34,51.46,5.67915949322386,0 +"bt_rear_0p1349","REVL","BT","held_out",592.75,412.05,561.14,412.05,31.61,5.63317532166661,0 +"bt_rear_0p1349","PARS","BT","in_sample",2775.11,1685.39,2634.99,1685.39,140.12,5.31766723972388,0 +"bt_rear_0p1349","BULK","BT","in_sample",3168.96,1853.38,3010.32,1853.38,158.64,5.26987164155305,0 +"bt_rear_0p1349","BABR","BT","held_out",1806.17,1000.77,1723.88,1000.77,82.29,4.77353412070446,0 +"bt_rear_0p1349","MORR","BT","in_sample",1770.21,962.09,1692.1,962.09,78.1100000000001,4.6161574375037,0 +"bt_rear_0p1349","BABL","BT","held_out",2096.78,1048.06,2055.08,1048.06,41.7000000000003,2.02911808786034,0 +"bt_rear_0p1449","KOTL","BT","in_sample",1778.67,1035.17,1599.21,1035.17,179.46,11.2217907591874,0 +"bt_rear_0p1449","UARL","BT","held_out",860.19,529.54,776.92,529.54,83.2700000000001,10.7179632394584,0 +"bt_rear_0p1449","BULL","BT","held_out",1168.28,715.43,1062.04,715.43,106.24,10.0033897028361,0 +"bt_rear_0p1449","ELKR","BT","held_out",2330.82,1536.57,2122.71,1536.57,208.11,9.80397699167574,0 +"bt_rear_0p1449","REVL","BT","held_out",604.71,412.05,561.14,412.05,43.57,7.76455073600172,0 +"bt_rear_0p1449","CLRH","BT","held_out",1063.72,733.49,988.11,733.49,75.61,7.65198206677394,0 +"bt_rear_0p1449","LILL","BT","held_out",967.58,670.34,906.12,670.34,61.46,6.78276607954797,0 +"bt_rear_0p1449","BULK","BT","in_sample",3213.68,1853.38,3010.32,1853.38,203.36,6.75542799436604,0 +"bt_rear_0p1449","PARS","BT","in_sample",2798.86,1685.39,2634.99,1685.39,163.87,6.2189989335823,0 +"bt_rear_0p1449","MORR","BT","in_sample",1786.66,962.09,1692.1,962.09,94.5600000000002,5.58832220317949,0 +"bt_rear_0p1449","BABR","BT","held_out",1818.81,1000.77,1723.88,1000.77,94.9299999999998,5.50676381186625,0 +"bt_rear_0p1449","BABL","BT","held_out",2104.52,1048.06,2055.08,1048.06,49.4400000000001,2.40574576172217,0 diff --git a/data-raw/logs/habitat_score_284/stamp_score.txt b/data-raw/logs/habitat_score_284/stamp_score.txt index 0c5b6570..11d3ab2e 100644 --- a/data-raw/logs/habitat_score_284/stamp_score.txt +++ b/data-raw/logs/habitat_score_284/stamp_score.txt @@ -1,5 +1,5 @@ -date: 2026-09-29 22:04 PDT -link: 0.53.0 @ 031c5cc (at launch) +date: 2026-09-30 10:08 PDT +link: 0.53.0 @ 002321f (at launch) fresh: 0.34.0 @ no recorded sha db: docker fwapg localhost:5432 variants: data-raw/habitat_score/variants.csv (md5 e7dec4a5b954d20a4d9582fdf483787e): default,bt_rear_0p1249,bt_rear_0p1349,bt_rear_0p1449 @@ -12,4 +12,4 @@ focal: ELKR,BULL,UARL,REVL,CLRH,LILL,BABL,BABR,PARS,KOTL,BULK,MORR; species: BT; rule: n_band >= 10 and density_ratio >= 0.5 on held-out WSGs pooling: default species_pooling.csv (sha256 9c42964e0469): 12 WSG x species pairs pooled (BT<-DV) bcfishobs.observations rows: 373050 -absences: FISS snapshots COTR,LNTH,PINE,UNTH,UPCE; knowledge @ 5e4e08e +absences: FISS snapshots COTR,LNTH,PINE,UNTH,UPCE; knowledge @ afa84ef diff --git a/data-raw/logs/habitat_score_284/taper.csv b/data-raw/logs/habitat_score_284/taper.csv index ce136cfe..5c138124 100644 --- a/data-raw/logs/habitat_score_284/taper.csv +++ b/data-raw/logs/habitat_score_284/taper.csv @@ -1,15 +1,15 @@ "species_code","column","role","taper_class","km","n","per_100km","ratio_to_core" -"BT","rear_gradient_max","held_out","band bt_rear_0p1249",422.199474061986,46,10.895323851883,0.603411835497523 +"BT","rear_gradient_max","held_out","band bt_rear_0p1249",422.199474061986,46,10.895323851883,0.603411835497524 "BT","rear_gradient_max","held_out","band bt_rear_0p1349",163.041225190392,21,12.8801779890191,0.713338304353902 "BT","rear_gradient_max","held_out","band bt_rear_0p1449",137.509597013536,8,5.81777575801674,0.322203800123956 "BT","rear_gradient_max","held_out","core (-Inf,0.02]",4872.14486710653,908,18.6365558653686,1.03214172749264 "BT","rear_gradient_max","held_out","core (0.02,0.05]",3045.06828125025,603,19.8025116123971,1.09671543883778 -"BT","rear_gradient_max","held_out","core (0.05,0.08]",1591.86910304486,249,15.6419896286524,0.866294733499562 +"BT","rear_gradient_max","held_out","core (0.05,0.08]",1591.86910304486,249,15.6419896286524,0.866294733499563 "BT","rear_gradient_max","held_out","core (0.08, Inf]",686.862396530564,81,11.7927550567832,0.653113947884755 "BT","rear_gradient_max","in_sample","band bt_rear_0p1249",383.636642052419,39,10.1658693995844,0.890601419706828 -"BT","rear_gradient_max","in_sample","band bt_rear_0p1349",137.577626542057,11,7.99548609499912,0.700460628359393 +"BT","rear_gradient_max","in_sample","band bt_rear_0p1349",137.577626542057,11,7.99548609499912,0.700460628359394 "BT","rear_gradient_max","in_sample","band bt_rear_0p1449",121.754733275809,9,7.39190974991701,0.647583109604966 -"BT","rear_gradient_max","in_sample","core (-Inf,0.02]",4295.08325339547,499,11.6179354522527,1.0178125845549 +"BT","rear_gradient_max","in_sample","core (-Inf,0.02]",4295.08325339546,499,11.6179354522527,1.0178125845549 "BT","rear_gradient_max","in_sample","core (0.02,0.05]",2553.40360190603,299,11.7098605084134,1.02586586384715 -"BT","rear_gradient_max","in_sample","core (0.05,0.08]",1443.37050177981,151,10.4616243586662,0.916511627293637 -"BT","rear_gradient_max","in_sample","core (0.08, Inf]",644.057638424171,71,11.023858077938,0.965767242225203 +"BT","rear_gradient_max","in_sample","core (0.05,0.08]",1443.37050177981,151,10.4616243586662,0.916511627293638 +"BT","rear_gradient_max","in_sample","core (0.08, Inf]",644.057638424171,71,11.0238580779381,0.965767242225204 diff --git a/planning/archive/2026-09-issue-284-step5-scoring/README.md b/planning/archive/2026-09-issue-284-step5-scoring/README.md index 3a2f4079..bd44e590 100644 --- a/planning/archive/2026-09-issue-284-step5-scoring/README.md +++ b/planning/archive/2026-09-issue-284-step5-scoring/README.md @@ -20,7 +20,7 @@ Held out, core 18.1 locations per 100 km. | to 0.1449 | 8 | 25 | 0.32 | 0.40 | - 0.1349 holds under both the rule's floor and the expected-count floor, so `default_tuned` is unchanged. -- Capture rises from 81.2 % to 84.2 % for +585 km (+5.7 %). +- Capture rises from 81.2 % to 84.2 % for +585 km (+5.7 %) on the held-out WSGs. Across all 12 the change adds 1,105 km of BT rearing (+5.8 %, from 2 % in BABL to 9 % in KOTL and UARL; `habitat_change.csv`). - The core tapers with gradient (18.6 / 19.8 / 15.6 / 11.8 per 100 km) and with elevation (24.6 / 19.3 / 10.2). The steep bands sit high, which is why the adjusted ratio exists. - 67–74 % of each band is bridge-only rearing; 101 km of the first band lies outside its gradient window (connectivity-admitted). - The build ran in 139.6 min (23 WSGs, 4 schemas). diff --git a/research/habitat_thresholds.md b/research/habitat_thresholds.md index 2b9a014f..72cf320c 100644 --- a/research/habitat_thresholds.md +++ b/research/habitat_thresholds.md @@ -355,6 +355,18 @@ The questions scoring must answer: ### Results, 2026-09-29 +**In plain terms.** The old line said BT stop rearing at about 10 % gradient. Moving it +to 12, 13 and 14 %, we checked whether bull trout turn up in the streams each move adds, +on watersheds not used to choose the number: +- between 10 and 13 % they do, at roughly two-thirds to nine-tenths of their rate in + normal rearing at the same elevation, so that water is habitat; +- past 13 % they mostly don't: 8 sightings where about 25 were expected. + +So 0.1349 holds. Steep water looks emptier than it is partly because it sits high, +where every stream holds fewer fish (colder, smaller, less sampled). Comparing like +with like by elevation is what the adjusted ratio does. Across the 12 watersheds the +change adds about 6 % more rearing (table below). + Run `20260930_014921-53610765`, link @ `a11a001` (build) and `031c5cc` (score). The 23-WSG closure was modelled clean; each variant differs from `default` in one cell, on one shared segmentation. Evidence: `data-raw/logs/habitat_score_284/` (`verdict.csv`, @@ -377,6 +389,28 @@ shared segmentation. Evidence: `data-raw/logs/habitat_score_284/` (`verdict.csv` - **Capture against cost** (held out, all stages): stream-rearing capture goes from 81.2 % under `default` to 84.2 % at 0.1349 (1,841 → 1,908 of 2,266 locations) for 585 km more rearing (+5.7 %). 0.1449 adds 138 km for 8 more. +- **How much rearing the change adds** (`habitat_change.csv`, `default` → 0.1349, BT + stream rearing): **19,133 → 20,237 km, +1,105 km (+5.8 %)** across the 12 WSGs. + Spawning is unchanged: the cutoff is a rearing threshold. + + | WSG | role | before | after | added | + |---|---|---|---|---| + | KOTL | in-sample | 1,599 km | 1,742 km | +143 km (+8.9 %) | + | UARL | held out | 777 | 846 | +69 (+8.8 %) | + | BULL | held out | 1,062 | 1,151 | +89 (+8.3 %) | + | ELKR | held out | 2,123 | 2,284 | +161 (+7.6 %) | + | CLRH | held out | 988 | 1,048 | +60 (+6.1 %) | + | LILL | held out | 906 | 958 | +51 (+5.7 %) | + | REVL | held out | 561 | 593 | +32 (+5.6 %) | + | PARS | in-sample | 2,635 | 2,775 | +140 (+5.3 %) | + | BULK | in-sample | 3,010 | 3,169 | +159 (+5.3 %) | + | BABR | held out | 1,724 | 1,806 | +82 (+4.8 %) | + | MORR | in-sample | 1,692 | 1,770 | +78 (+4.6 %) | + | BABL | held out | 2,055 | 2,097 | +42 (+2.0 %) | + + The mountainous Kootenay and Columbia groups gain most, and the Babine least. These are + the only WSGs modelled at both cutoffs, so "about 6 %" elsewhere is a guess, not a + measurement. - **In-sample WSGs agree** (ratios 0.89, 0.70, 0.65; elevation-adjusted 0.94, 0.75, 0.69), and never decide. - **The core itself tapers** with gradient: 18.6, 19.8, 15.6 and 11.8 locations per @@ -384,7 +418,8 @@ shared segmentation. Evidence: `data-raw/logs/habitat_score_284/` (`verdict.csv` cliff the fish see (knowledge#28 takes up weights instead of cutoffs). - **Elevation is a confound.** Core rearing thins from 24.6 to 19.3 to 10.2 per 100 km across the low, mid and high thirds of each WSG's own rearing, and the steep bands - sit mostly high (263 of the first band's 422 km). The elevation-adjusted ratio + sit mostly high: 263 of the first band's 422 km, and 366 of the 585 km the two steps + to 0.1349 add (63 %; `elevation.csv`, held out). The elevation-adjusted ratio compares each band with the core at its own elevation mix. It raises the first two steps, and the third stays low. - **Question 2 (the bridge).** Of the first band's 422 km, 140 km has spawning upstream @@ -395,6 +430,10 @@ shared segmentation. Evidence: `data-raw/logs/habitat_score_284/` (`verdict.csv` rearing (BULK, KOTL, LILL; 0.07 km held out) while adding 1,365 km, when a newly admitted segment merges clusters. - **Absences** do not reach these WSGs: the FISS snapshots cover none of the twelve. +- **Re-running the score changes only the last digit or two** of the km sums and ratios + (`bands*.csv`, `taper.csv`, `elevation.csv`, `bridge_band.csv`). The double-precision + length sums in Postgres depend on summation order, the same effect as #293. No count, + ratio at printed precision, or verdict moves. **The floor, discussed after the build (2026-09-29).** The rule's floor is on the locations *found* in a band. A band fish avoid produces few, so it reads as