riftprospect 0.1.0__tar.gz

riftprospect-0.1.0/AUTHORS.json

@@ -0,0 +1,23 @@
+{
+  "_comment": "Author block. Every document, citation file, Zenodo record and commit reads from here. ORCID and email copied from MCR-GeoChem's AUTHORS.json; confirm in the verification checklist.",
+  "authors": [
+    {
+      "name": "Bezali Kwame Danso",
+      "family": "Danso",
+      "given": "Bezali Kwame",
+      "orcid": "0009-0006-1201-4129",
+      "email": "dansobez@msu.edu",
+      "affiliation": "Independent Researcher, East Lansing, Michigan, USA",
+      "roles": [
+        "Conceptualization",
+        "Methodology",
+        "Validation",
+        "Formal analysis",
+        "Writing - original draft"
+      ],
+      "corresponding": true,
+      "github": "bkdanso"
+    }
+  ],
+  "collaborators": []
+}

riftprospect-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bezali Kwame Danso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

riftprospect-0.1.0/LICENSE-DATA.md

@@ -0,0 +1,14 @@
+# Data license
+
+*Plain-language note: the code is MIT (anyone may reuse it with credit). The data products are CC BY-SA 4.0: anyone may reuse them with credit, and must share their own derived versions under the same license. This is required because they are built from MCR-GeoChem, which is CC BY-SA 4.0.*
+
+The following are licensed under the Creative Commons Attribution-ShareAlike 4.0 International License (https://creativecommons.org/licenses/by-sa/4.0/):
+`data/processed/` (including `targets_ranked.csv`), `site/data/`, `site/img/`, and `paper/figures/`.
+
+Documentation in `docs/` and `paper/` text: CC BY 4.0.
+
+Attribution for the underlying sources (please cite them too):
+- USGS, Critical mineral deposits of the United States, ver. 3.0 (Hammarstrom, Woodruff, Dicken and Zach, 2026), doi:10.5066/P9K1HBNT. CC0.
+- USGS, Airborne magnetic and radiometric survey, Upper Peninsula, Michigan, and parts of northern Wisconsin, 2025 (Drenth, Murchek, Brown and Connell, 2026), doi:10.5066/P14ESDF7. Public domain.
+- MCR-GeoChem v1.0.1 (Danso and Abdullah, 2026), doi:10.5281/zenodo.23516434. CC BY-SA 4.0.
+- USGS State Geologic Map Compilation (Horton, San Juan and Stoeser, 2017), doi:10.3133/ds1052. Public domain.

riftprospect-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: riftprospect
+Version: 0.1.0
+Summary: Open prospectivity modeling for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift
+Author: Bezali Kwame Danso
+License: MIT
+Project-URL: Source, https://github.com/bkdanso/riftprospect
+Keywords: mineral prospectivity,critical minerals,nickel,platinum-group elements,Midcontinent Rift,geochemistry,aeromagnetics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-DATA.md
+License-File: AUTHORS.json
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: rasterio>=1.3
+Requires-Dist: geopandas>=0.14
+Requires-Dist: pyproj>=3.5
+Requires-Dist: pyarrow>=12
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# riftprospect: open prospectivity model for magmatic Ni-Cu-Co-PGE in the Midcontinent Rift
+
+**Status:** Released | v0.1.0 | built 2026-10-27 | **Software DOI:** [10.5281/zenodo.23697827](https://doi.org/10.5281/zenodo.23697827) | **Target table DOI:** [10.5281/zenodo.23697829](https://doi.org/10.5281/zenodo.23697829) | **Map:** [https://bkdanso.github.io/riftprospect/](https://bkdanso.github.io/riftprospect/) | **Maintainer:** Bezali Kwame Danso ([ORCID](https://orcid.org/0009-0006-1201-4129)) | Code MIT, data CC BY-SA 4.0
+
+**In plain terms:** Nickel, cobalt, copper and the platinum-group metals are on the 2025 U.S. critical minerals list. The Eagle mine near Marquette, Michigan, is the only U.S. mine that produces nickel as its main product, and the rock around Lake Superior could hold more deposits like it, mostly hidden under glacial sediment. This project turns free public data into a ranked list of places worth checking. It scores every 200 m square of the 2025 USGS airborne survey of the Upper Peninsula and northern Wisconsin (39,368.6 km², 984,215 squares) by how much its magnetism and natural radioactivity look like the small, dense, magnetic intrusions that host deposits like Eagle. It also tests which rock-chemistry signals actually tell you a deposit is nearby. The Eagle mine was held out of every fitting step. It still ranks at the **98.86th percentile** of the survey area.
+
+New here? Read [docs/START_HERE.md](docs/START_HERE.md). Terms are explained in [docs/GLOSSARY.md](docs/GLOSSARY.md).
+
+![Prospectivity map](paper/figures/fig3_prospectivity.png)
+
+## What it found (validation study)
+
+| Test | Result |
+|---|---|
+| Held-out Eagle mine, final score | 98.86th percentile; captured within the top 1.14% of the area |
+| Eagle, range across 200 random weightings | 97.6th to 98.77th percentile |
+| Eagle, magnetics only / radiometrics only | 95.6th / 88.44th percentile |
+| Chemistry model (Ni/Cu, MgO, Mg-number), spatial cross-validation in Minnesota | AUC 0.29 with near = 3 km (0.48 at 2 km, 0.35 at 5 km; 0.5 = chance): **does not discriminate, and is unstable** |
+| Cu/Pd within 3 km of a deposit vs more than 10 km away (igneous rocks) | median 21,736 vs 31,568 (n = 330 vs 138) |
+| Targets (top 2% of non-edge squares) | 1,629 targets covering 751.8 km² |
+
+Interpretation and caveats: [docs/LIMITATIONS.md](docs/LIMITATIONS.md). Every modeling choice: [docs/DECISIONS.md](docs/DECISIONS.md).
+
+## Interactive map
+
+Open it at **https://bkdanso.github.io/riftprospect/**. The source is `site/`, a static Leaflet map: score, uncertainty, the 1,629 targets with popups, known deposits, and Cu/Pd sample labels.
+
+## Install and use
+
+```
+pip install riftprospect
+riftprospect fertility my_samples.csv > fertility.csv
+```
+
+`my_samples.csv` needs columns `Cu_ppm, Ni_ppm, Pd_ppb, Pt_ppb, MgO_wt, Fe2O3T_wt` (negative = below detection, as in MCR-GeoChem). Output: Cu/Pd, Ni/Cu, Pd/Pt, Mg-number and a Cu/Pd fertility class per sample.
+
+## Rebuild everything
+
+```
+./run_all.sh            # about 1 GB of downloads; about 10 minutes
+```
+
+Expected: `paper/stats.json` with 984,215 cells, Eagle at the 98.86th percentile, 1,629 targets, and 14 passing tests.
+
+## Pipeline
+
+| Script | Does |
+|---|---|
+| `01_fetch.py`, `01b_fetch_sgmc.py` | Download all sources; log size and SHA-256 to `data/raw/PROVENANCE.txt` |
+| `02_grid.py` | Average the two survey blocks onto one 200 m grid; analytic signal, residual field, edge distance |
+| `03_fertility.py` | Cu/Pd, Ni/Cu, MgO, Mg-number per sample |
+| `05_chem_model.py` | Part A: chemistry model trained in Minnesota, spatial cross-validation (reported, not used on the map) |
+| `06_geophys.py` | Part B: rule-based geophysics score with Monte Carlo uncertainty |
+| `08_combine.py` | Geology mask, targets, held-out Eagle test |
+| `09_validate.py` | All validation numbers into `paper/stats.json` |
+| `04`, `07`, `10` | Figures and the web map |
+
+## Outputs
+
+| File | One row is |
+|---|---|
+| `data/processed/targets_ranked.csv` | one target: location, area, peak and mean score, uncertainty, mapped geology, nearby Cu/Pd label |
+| `data/processed/prospectivity_cells.parquet` | one 200 m square with every evidence layer and score |
+| `data/processed/sample_scores.csv` | one rock sample with indicators and chemistry-model score |
+| `paper/stats.json` | every number quoted anywhere |
+
+Column definitions: [docs/CODEBOOK.md](docs/CODEBOOK.md).
+
+## Sources
+
+| Source | Vintage | License |
+|---|---|---|
+| USGS Critical Mineral Deposits of the United States (Hammarstrom, Woodruff, Dicken and Zach), [doi:10.5066/P9K1HBNT](https://doi.org/10.5066/P9K1HBNT) | ver. 3.0, Sept 2026 | CC0 |
+| USGS Airborne magnetic and radiometric survey, Upper Peninsula, Michigan, and parts of northern Wisconsin, 2025 (Drenth, Murchek, Brown and Connell), [doi:10.5066/P14ESDF7](https://doi.org/10.5066/P14ESDF7) | released Sept 2026 | Public domain |
+| MCR-GeoChem (Danso and Abdullah), [doi:10.5281/zenodo.23516434](https://doi.org/10.5281/zenodo.23516434) | v1.0.1, Oct 2026 | CC BY-SA 4.0 |
+| USGS State Geologic Map Compilation (Horton, San Juan and Stoeser), [doi:10.3133/ds1052](https://doi.org/10.3133/ds1052) | 2017 | Public domain |
+
+## Cite
+
+Software: Danso, B.K. (2026). riftprospect v0.1.0: open prospectivity model for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift. Zenodo. https://doi.org/10.5281/zenodo.23697827
+
+Target table: Danso, B.K. (2026). Ranked prospectivity targets for magmatic Ni-Cu-Co-PGE deposits, Upper Peninsula of Michigan and northern Wisconsin (v0.1.0). Zenodo. https://doi.org/10.5281/zenodo.23697829
+
+See also `CITATION.cff`. Please also cite the sources above.
+
+## AI assistance
+
+Claude (Anthropic) assisted with code, tests and drafting. Bezali Kwame Danso made every modeling decision (docs/DECISIONS.md) and verified the outputs.

riftprospect-0.1.0/README.md

@@ -0,0 +1,88 @@
+# riftprospect: open prospectivity model for magmatic Ni-Cu-Co-PGE in the Midcontinent Rift
+
+**Status:** Released | v0.1.0 | built 2026-10-27 | **Software DOI:** [10.5281/zenodo.23697827](https://doi.org/10.5281/zenodo.23697827) | **Target table DOI:** [10.5281/zenodo.23697829](https://doi.org/10.5281/zenodo.23697829) | **Map:** [https://bkdanso.github.io/riftprospect/](https://bkdanso.github.io/riftprospect/) | **Maintainer:** Bezali Kwame Danso ([ORCID](https://orcid.org/0009-0006-1201-4129)) | Code MIT, data CC BY-SA 4.0
+
+**In plain terms:** Nickel, cobalt, copper and the platinum-group metals are on the 2025 U.S. critical minerals list. The Eagle mine near Marquette, Michigan, is the only U.S. mine that produces nickel as its main product, and the rock around Lake Superior could hold more deposits like it, mostly hidden under glacial sediment. This project turns free public data into a ranked list of places worth checking. It scores every 200 m square of the 2025 USGS airborne survey of the Upper Peninsula and northern Wisconsin (39,368.6 km², 984,215 squares) by how much its magnetism and natural radioactivity look like the small, dense, magnetic intrusions that host deposits like Eagle. It also tests which rock-chemistry signals actually tell you a deposit is nearby. The Eagle mine was held out of every fitting step. It still ranks at the **98.86th percentile** of the survey area.
+
+New here? Read [docs/START_HERE.md](docs/START_HERE.md). Terms are explained in [docs/GLOSSARY.md](docs/GLOSSARY.md).
+
+![Prospectivity map](paper/figures/fig3_prospectivity.png)
+
+## What it found (validation study)
+
+| Test | Result |
+|---|---|
+| Held-out Eagle mine, final score | 98.86th percentile; captured within the top 1.14% of the area |
+| Eagle, range across 200 random weightings | 97.6th to 98.77th percentile |
+| Eagle, magnetics only / radiometrics only | 95.6th / 88.44th percentile |
+| Chemistry model (Ni/Cu, MgO, Mg-number), spatial cross-validation in Minnesota | AUC 0.29 with near = 3 km (0.48 at 2 km, 0.35 at 5 km; 0.5 = chance): **does not discriminate, and is unstable** |
+| Cu/Pd within 3 km of a deposit vs more than 10 km away (igneous rocks) | median 21,736 vs 31,568 (n = 330 vs 138) |
+| Targets (top 2% of non-edge squares) | 1,629 targets covering 751.8 km² |
+
+Interpretation and caveats: [docs/LIMITATIONS.md](docs/LIMITATIONS.md). Every modeling choice: [docs/DECISIONS.md](docs/DECISIONS.md).
+
+## Interactive map
+
+Open it at **https://bkdanso.github.io/riftprospect/**. The source is `site/`, a static Leaflet map: score, uncertainty, the 1,629 targets with popups, known deposits, and Cu/Pd sample labels.
+
+## Install and use
+
+```
+pip install riftprospect
+riftprospect fertility my_samples.csv > fertility.csv
+```
+
+`my_samples.csv` needs columns `Cu_ppm, Ni_ppm, Pd_ppb, Pt_ppb, MgO_wt, Fe2O3T_wt` (negative = below detection, as in MCR-GeoChem). Output: Cu/Pd, Ni/Cu, Pd/Pt, Mg-number and a Cu/Pd fertility class per sample.
+
+## Rebuild everything
+
+```
+./run_all.sh            # about 1 GB of downloads; about 10 minutes
+```
+
+Expected: `paper/stats.json` with 984,215 cells, Eagle at the 98.86th percentile, 1,629 targets, and 14 passing tests.
+
+## Pipeline
+
+| Script | Does |
+|---|---|
+| `01_fetch.py`, `01b_fetch_sgmc.py` | Download all sources; log size and SHA-256 to `data/raw/PROVENANCE.txt` |
+| `02_grid.py` | Average the two survey blocks onto one 200 m grid; analytic signal, residual field, edge distance |
+| `03_fertility.py` | Cu/Pd, Ni/Cu, MgO, Mg-number per sample |
+| `05_chem_model.py` | Part A: chemistry model trained in Minnesota, spatial cross-validation (reported, not used on the map) |
+| `06_geophys.py` | Part B: rule-based geophysics score with Monte Carlo uncertainty |
+| `08_combine.py` | Geology mask, targets, held-out Eagle test |
+| `09_validate.py` | All validation numbers into `paper/stats.json` |
+| `04`, `07`, `10` | Figures and the web map |
+
+## Outputs
+
+| File | One row is |
+|---|---|
+| `data/processed/targets_ranked.csv` | one target: location, area, peak and mean score, uncertainty, mapped geology, nearby Cu/Pd label |
+| `data/processed/prospectivity_cells.parquet` | one 200 m square with every evidence layer and score |
+| `data/processed/sample_scores.csv` | one rock sample with indicators and chemistry-model score |
+| `paper/stats.json` | every number quoted anywhere |
+
+Column definitions: [docs/CODEBOOK.md](docs/CODEBOOK.md).
+
+## Sources
+
+| Source | Vintage | License |
+|---|---|---|
+| USGS Critical Mineral Deposits of the United States (Hammarstrom, Woodruff, Dicken and Zach), [doi:10.5066/P9K1HBNT](https://doi.org/10.5066/P9K1HBNT) | ver. 3.0, Sept 2026 | CC0 |
+| USGS Airborne magnetic and radiometric survey, Upper Peninsula, Michigan, and parts of northern Wisconsin, 2025 (Drenth, Murchek, Brown and Connell), [doi:10.5066/P14ESDF7](https://doi.org/10.5066/P14ESDF7) | released Sept 2026 | Public domain |
+| MCR-GeoChem (Danso and Abdullah), [doi:10.5281/zenodo.23516434](https://doi.org/10.5281/zenodo.23516434) | v1.0.1, Oct 2026 | CC BY-SA 4.0 |
+| USGS State Geologic Map Compilation (Horton, San Juan and Stoeser), [doi:10.3133/ds1052](https://doi.org/10.3133/ds1052) | 2017 | Public domain |
+
+## Cite
+
+Software: Danso, B.K. (2026). riftprospect v0.1.0: open prospectivity model for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift. Zenodo. https://doi.org/10.5281/zenodo.23697827
+
+Target table: Danso, B.K. (2026). Ranked prospectivity targets for magmatic Ni-Cu-Co-PGE deposits, Upper Peninsula of Michigan and northern Wisconsin (v0.1.0). Zenodo. https://doi.org/10.5281/zenodo.23697829
+
+See also `CITATION.cff`. Please also cite the sources above.
+
+## AI assistance
+
+Claude (Anthropic) assisted with code, tests and drafting. Bezali Kwame Danso made every modeling decision (docs/DECISIONS.md) and verified the outputs.

riftprospect-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "riftprospect"
+version = "0.1.0"
+description = "Open prospectivity modeling for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Bezali Kwame Danso"}]
+requires-python = ">=3.10"
+dependencies = ["numpy>=1.24", "pandas>=2.0", "scipy>=1.10", "scikit-learn>=1.3", "rasterio>=1.3",
+                "geopandas>=0.14", "pyproj>=3.5", "pyarrow>=12", "openpyxl>=3.1", "matplotlib>=3.7"]
+keywords = ["mineral prospectivity", "critical minerals", "nickel", "platinum-group elements", "Midcontinent Rift", "geochemistry", "aeromagnetics"]
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License",
+               "Topic :: Scientific/Engineering :: GIS", "Intended Audience :: Science/Research"]
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[project.scripts]
+riftprospect = "riftprospect.cli:main"
+
+[project.urls]
+Source = "https://github.com/bkdanso/riftprospect"
+
+[tool.setuptools.packages.find]
+where = ["src"]

riftprospect-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

riftprospect-0.1.0/src/riftprospect/__init__.py

@@ -0,0 +1,2 @@
+"""riftprospect: open prospectivity modeling for magmatic Ni-Cu-Co-PGE in the Midcontinent Rift."""
+__version__ = "0.1.0"

riftprospect-0.1.0/src/riftprospect/chemmodel.py

@@ -0,0 +1,105 @@
+"""Part A: chemistry similarity model, trained where deposits and samples coexist (Minnesota).
+
+Plain-language note: this learns how rock chemistry near known Ni-Cu-PGE deposits differs
+from rock chemistry far from them, then scores other samples by that similarity. It uses
+many resampled copies of the training data (bootstrap) so each score carries a spread.
+Choices marked DECISION are listed in docs/DECISIONS.md.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import roc_auc_score
+
+# DECISION D2: samples within NEAR_KM of a deposit are positives; beyond FAR_KM negatives;
+# between is a buffer left out of training (it is neither clearly near nor clearly far).
+NEAR_KM, FAR_KM = 3.0, 10.0  # D2 decided by Bezali 2026-10-27: 3 km
+# DECISION D9: model features. Cu/Pd is excluded from the main model because Pd was analyzed
+# far more often near deposits than away from them, so its presence alone leaks the label.
+FEATURES = ["log_ni_cu", "MgO_wt", "mg_number"]
+# DECISION D8: rocks used.
+ROCK_CLASSES = ["igneous_intrusive"]
+
+
+def add_features(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    df["log_ni_cu"] = np.log10(df["ni_cu"].where(df["ni_cu"] > 0))
+    df["log_cu_pd"] = np.log10(df["cu_pd"].where(df["cu_pd"] > 0))
+    return df
+
+
+def nearest_deposit(xy: np.ndarray, dep_xy: np.ndarray, names) -> tuple[np.ndarray, np.ndarray]:
+    d = np.hypot(xy[:, :1] - dep_xy[None, :, 0], xy[:, 1:] - dep_xy[None, :, 1])
+    return d.min(1) / 1000.0, np.asarray(names)[d.argmin(1)]
+
+
+def training_table(samples: pd.DataFrame) -> pd.DataFrame:
+    """Rows usable for training: chosen rock classes, not altered, all features present, outside buffer."""
+    s = add_features(samples)
+    s = s[s.rock_class.isin(ROCK_CLASSES) & ~s.altered_likely.fillna(False).astype(bool)]
+    s = s.dropna(subset=FEATURES)
+    s = s[(s.dep_km <= NEAR_KM) | (s.dep_km > FAR_KM)].copy()
+    s["label"] = (s.dep_km <= NEAR_KM).astype(int)
+    return s
+
+
+def spatial_groups(df: pd.DataFrame, block_km: float = 20.0) -> np.ndarray:
+    """Group id per row for spatial cross-validation: positives by nearest deposit, negatives by block."""
+    blk = (np.floor(df.x / (block_km * 1000)).astype(int).astype(str) + "_" +
+           np.floor(df.y / (block_km * 1000)).astype(int).astype(str))
+    return np.where(df.label == 1, "dep_" + df.dep_name.astype(str), "blk_" + blk)
+
+
+def make_model():
+    return make_pipeline(StandardScaler(), LogisticRegression(C=1.0, max_iter=1000))
+
+
+def spatial_cv_auc(train: pd.DataFrame, n_folds: int = 5, seed: int = 0) -> dict:
+    """Grouped spatial CV: whole deposits and whole 20 km blocks are held out together."""
+    from sklearn.model_selection import GroupKFold
+    g = spatial_groups(train)
+    X, y = train[FEATURES].values, train.label.values
+    oof = np.full(len(y), np.nan)
+    for tr, te in GroupKFold(n_splits=n_folds).split(X, y, g):
+        if len(np.unique(y[tr])) < 2:
+            continue
+        m = make_model().fit(X[tr], y[tr])
+        oof[te] = m.predict_proba(X[te])[:, 1]
+    ok = ~np.isnan(oof)
+    return {"auc": float(roc_auc_score(y[ok], oof[ok])), "n": int(ok.sum()),
+            "n_pos": int(y[ok].sum()), "n_groups": int(len(np.unique(g)))}
+
+
+def leave_one_deposit_out(train: pd.DataFrame) -> pd.DataFrame:
+    """Hold out each deposit's positives plus negatives; report the held-out positives' median rank."""
+    out = []
+    neg = train[train.label == 0]
+    for dep in sorted(train.loc[train.label == 1, "dep_name"].unique()):
+        te_pos = train[(train.label == 1) & (train.dep_name == dep)]
+        tr = train.drop(te_pos.index)
+        m = make_model().fit(tr[FEATURES].values, tr.label.values)
+        p_pos = m.predict_proba(te_pos[FEATURES].values)[:, 1]
+        p_neg = m.predict_proba(neg[FEATURES].values)[:, 1]  # in-sample for negatives: optimistic
+        pct = [(p_neg < p).mean() * 100 for p in p_pos]
+        out.append({"deposit": dep, "n_heldout": len(te_pos), "median_pct_vs_neg": float(np.median(pct))})
+    return pd.DataFrame(out)
+
+
+def bootstrap_predict(train: pd.DataFrame, apply: pd.DataFrame, n_boot: int = 200, seed: int = 0):
+    """Mean and standard deviation of predicted similarity across bootstrap refits."""
+    rng = np.random.default_rng(seed)
+    X, y = train[FEATURES].values, train.label.values
+    Xa = apply[FEATURES].values
+    preds = np.empty((n_boot, len(Xa)))
+    coefs = []
+    for b in range(n_boot):
+        i = rng.integers(0, len(y), len(y))
+        while len(np.unique(y[i])) < 2:
+            i = rng.integers(0, len(y), len(y))
+        m = make_model().fit(X[i], y[i])
+        preds[b] = m.predict_proba(Xa)[:, 1]
+        coefs.append(m[-1].coef_[0])
+    return preds.mean(0), preds.std(0), np.array(coefs)

riftprospect-0.1.0/src/riftprospect/cli.py

@@ -0,0 +1,35 @@
+"""Command line: `riftprospect fertility my_table.csv` scores your own samples.
+
+Plain-language note: lets anyone compute the fertility indicators (Cu/Pd, Ni/Cu, MgO,
+Mg-number, Cu/Pd class) on their own spreadsheet laid out like MCR-GeoChem's wide table.
+"""
+import argparse
+import sys
+
+import pandas as pd
+
+from . import __version__
+from .fertility import indicators, cu_pd_class
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="riftprospect", description=__doc__)
+    ap.add_argument("--version", action="version", version=__version__)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    f = sub.add_parser("fertility", help="compute fertility indicators for a CSV of samples")
+    f.add_argument("csv"); f.add_argument("--out", default="-")
+    f.add_argument("--id-col", default="mcr_uid")
+    f.add_argument("--censored", choices=["drop", "half"], default="drop")
+    a = ap.parse_args(argv)
+    df = pd.read_csv(a.csv, low_memory=False)
+    need = ["Cu_ppm", "Ni_ppm", "Pd_ppb", "Pt_ppb", "MgO_wt", "Fe2O3T_wt"]
+    missing = [c for c in need if c not in df.columns]
+    if missing:
+        sys.exit(f"missing columns: {', '.join(missing)} (units: Cu, Ni ppm; Pd, Pt ppb; oxides wt%)")
+    out = indicators(df.rename(columns={a.id_col: "mcr_uid"}), rule=a.censored)
+    out["cu_pd_class"] = cu_pd_class(out.cu_pd)
+    out.rename(columns={"mcr_uid": a.id_col}).to_csv(sys.stdout if a.out == "-" else a.out, index=False)
+
+
+if __name__ == "__main__":
+    main()

riftprospect-0.1.0/src/riftprospect/combine.py

@@ -0,0 +1,69 @@
+"""Combine chemistry and geophysics on the grid, and turn high-scoring cells into ranked targets.
+
+Plain-language note: each 200 m square gets a geophysics score everywhere, and a chemistry
+score only where rock samples are close enough. Where chemistry exists the two are blended;
+where it does not, the square is marked "geophysics only". Adjacent high-scoring squares are
+grouped into targets and ranked. Choices marked DECISION are in docs/DECISIONS.md.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.spatial import cKDTree
+
+CHEM_RADIUS_KM = 5.0     # DECISION D10: how far a sample's chemistry is allowed to reach
+CHEM_WEIGHT = 0.3        # DECISION D10: share of the blended score from chemistry
+TARGET_TOP_PCT = 2.0     # DECISION D7: cells in the top 2% of combined score become target cells
+EDGE_M = 1000.0          # QA rule: cells within 1 km of a data edge cannot become targets (derivative artifacts)
+MIN_TARGET_CELLS = 1     # DECISION D7: single 200 m cells kept, because Eagle-type intrusions are about one cell across (changed from 3 after Eagle dropped out: disclosed)
+
+
+def chem_to_grid(cells_xy, samp_xy, samp_mean, samp_sd, radius_km=CHEM_RADIUS_KM, power=2.0):
+    """Inverse-distance-weighted chemistry score per cell from samples within `radius_km`."""
+    n = len(cells_xy)
+    mean = np.full(n, np.nan); sd = np.full(n, np.nan); count = np.zeros(n, dtype=int)
+    if len(samp_xy) == 0:
+        return mean, sd, count
+    tree = cKDTree(samp_xy)
+    nbrs = tree.query_ball_point(cells_xy, r=radius_km * 1000)
+    for i, js in enumerate(nbrs):
+        if not js:
+            continue
+        d = np.hypot(*(samp_xy[js] - cells_xy[i]).T)
+        w = 1.0 / np.maximum(d, 100.0) ** power
+        w /= w.sum()
+        mean[i] = (w * samp_mean[js]).sum()
+        sd[i] = np.sqrt((w * samp_sd[js] ** 2).sum())
+        count[i] = len(js)
+    return mean, sd, count
+
+
+def blend(g_mean, g_sd, c_mean, c_sd, wc=CHEM_WEIGHT):
+    has = ~np.isnan(c_mean)
+    m = g_mean.copy(); s = g_sd.copy()
+    m[has] = (1 - wc) * g_mean[has] + wc * c_mean[has]
+    s[has] = np.sqrt(((1 - wc) * g_sd[has]) ** 2 + (wc * c_sd[has]) ** 2)
+    return m, s, np.where(has, "geophysics+chemistry", "geophysics only")
+
+
+def targets(grid: pd.DataFrame, shape, score_col="score", top_pct=TARGET_TOP_PCT,
+            min_cells=MIN_TARGET_CELLS) -> tuple[pd.DataFrame, np.ndarray]:
+    """Connected groups (8-neighbour) of cells above the top-`top_pct` threshold (computed on non-edge
+    cells), excluding edge cells, ranked by peak score then size."""
+    from scipy.ndimage import label
+    thr = np.nanpercentile(grid.loc[grid["edge_dist_m"] >= EDGE_M, score_col], 100 - top_pct)
+    img = np.zeros(shape, bool)
+    hi = (grid[score_col] >= thr) & (grid["edge_dist_m"] >= EDGE_M)
+    img[grid.row[hi], grid.col[hi]] = True
+    lab, _ = label(img, structure=np.ones((3, 3)))
+    g = grid.assign(target=lab[grid.row, grid.col])
+    g = g[g.target > 0]
+    agg = g.groupby("target").agg(
+        n_cells=("cell_id", "size"), score_mean=(score_col, "mean"), score_max=(score_col, "max"),
+        score_sd_mean=("score_sd", "mean"), x=("x", "mean"), y=("y", "mean"),
+        block=("block", "first"))
+    agg = agg[agg.n_cells >= min_cells].sort_values(["score_max", "n_cells"], ascending=False)
+    agg["rank"] = np.arange(1, len(agg) + 1)
+    keep = set(agg.index)
+    lab[~np.isin(lab, list(keep))] = 0
+    return agg.reset_index(), lab

riftprospect-0.1.0/src/riftprospect/fertility.py

@@ -0,0 +1,82 @@
+"""Geochemical fertility indicators for magmatic Ni-Cu-PGE sulfide systems.
+
+Plain-language note: this file computes the chemistry ratios you named (Cu/Pd,
+Ni/Cu, MgO, Mg-number) for each rock sample, and records whether each value is a
+real measurement or rests on a "below detection" value. The provisional choices
+(marked DECISION) are listed in docs/DECISIONS.md for you to rule on.
+
+Conventions follow MCR-GeoChem's wide table: Pd and Pt in ppb, Cu and Ni in ppm,
+oxides in wt%, and a negative number means "below detection, limit = |value|".
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+MW = {"MgO": 40.304, "FeO": 71.844, "Fe2O3": 159.688}
+
+# DECISION D3: share of total iron taken as Fe2+ for Mg-number (0.9 is a common choice for
+# basalts near the FMQ buffer; 0.85 and 1.0 are also used).
+FE2_FRACTION = 0.9
+
+# DECISION D4: how to treat a below-detection value in a ratio.
+#   "drop": ratio is NaN.  "half": use half the limit and flag the ratio as censored.
+CENSORED_RULE = "drop"
+
+
+def _value(series, rule=CENSORED_RULE):
+    s = pd.to_numeric(series, errors="coerce")
+    censored = s < 0
+    if rule == "drop":
+        v = s.where(s > 0)
+    elif rule == "half":
+        v = s.where(s > 0, s.abs() / 2).where(s != 0)
+    else:
+        raise ValueError(rule)
+    return v, censored
+
+
+def mg_number(mgo_wt, fe2o3t_wt, fe2_fraction=FE2_FRACTION):
+    """Molar 100*Mg/(Mg+Fe2+), with Fe2+ = fe2_fraction * total Fe (from Fe2O3T)."""
+    mg = mgo_wt / MW["MgO"]
+    fet = 2 * fe2o3t_wt / MW["Fe2O3"]
+    return 100 * mg / (mg + fe2_fraction * fet)
+
+
+def indicators(wide: pd.DataFrame, rule: str = CENSORED_RULE) -> pd.DataFrame:
+    """Return one row per sample with Cu/Pd, Ni/Cu, Pd/Pt, MgO, Mg#, and censoring flags."""
+    cu, cu_c = _value(wide["Cu_ppm"], rule)
+    ni, ni_c = _value(wide["Ni_ppm"], rule)
+    pd_, pd_c = _value(wide["Pd_ppb"], rule)
+    pt, pt_c = _value(wide["Pt_ppb"], rule)
+    mgo, _ = _value(wide["MgO_wt"], "drop")
+    fe, _ = _value(wide["Fe2O3T_wt"], "drop")
+    out = pd.DataFrame({"mcr_uid": wide["mcr_uid"]})
+    out["Cu_ppm"], out["Ni_ppm"], out["Pd_ppb"], out["Pt_ppb"] = cu, ni, pd_, pt
+    out["MgO_wt"] = mgo
+    out["mg_number"] = mg_number(mgo, fe)
+    # Cu/Pd uses both in ppm; primitive mantle about 7,000 (see D5).
+    out["cu_pd"] = cu / (pd_ / 1000.0)
+    out["ni_cu"] = ni / cu
+    out["pd_pt"] = pd_ / pt
+    out["cu_pd_censored"] = cu_c | pd_c
+    out["ni_cu_censored"] = ni_c | cu_c
+    return out
+
+
+# DECISION D5 (kept by Bezali 2026-10-27): fertility classes from Cu/Pd. Primitive-mantle Cu/Pd is
+# taken as 7,000, rounded from McDonough and Sun (1995) primitive mantle Cu 30 ppm and Pd 3.9 ppb
+# (ratio about 7,700). Values well above mantle mean the magma lost PGE to sulfide earlier
+# (PGE-depleted, sulfide saturation upstream); values below mantle mean PGE-enriched
+# (sulfide-bearing or cumulate). Thresholds below are provisional.
+CU_PD_MANTLE = 7000.0
+CU_PD_DEPLETED = 3 * CU_PD_MANTLE   # above this: PGE-depleted
+CU_PD_ENRICHED = CU_PD_MANTLE / 3   # below this: PGE-enriched
+
+
+def cu_pd_class(cu_pd: pd.Series) -> pd.Series:
+    c = pd.Series("undetermined", index=cu_pd.index, dtype="object")
+    c[cu_pd > CU_PD_DEPLETED] = "pge_depleted"
+    c[(cu_pd <= CU_PD_DEPLETED) & (cu_pd >= CU_PD_ENRICHED)] = "mantle_like"
+    c[cu_pd < CU_PD_ENRICHED] = "pge_enriched"
+    return c

riftprospect-0.1.0/src/riftprospect/geology.py

@@ -0,0 +1,53 @@
+"""Geology mask (decision D11): down-weight rock types that are magnetic but not Ni-Cu hosts.
+
+Plain-language note: iron formation and the thick Keweenawan lava pile are strongly magnetic,
+so the geophysics score flags them even though magmatic nickel deposits are not hosted there.
+This module paints each 200 m square with its mapped rock type from the USGS State Geologic
+Map Compilation and applies a multiplier. Multipliers are DECISION D11.
+"""
+from __future__ import annotations
+import numpy as np
+import geopandas as gpd
+from rasterio.features import rasterize
+
+# class code: (label, multiplier)
+CLASSES = {0: ("other or unmapped", 1.0),
+           1: ("iron formation (+500 m)", 0.3),
+           2: ("Mesoproterozoic volcanic", 0.6),
+           3: ("intrusive", 1.0),
+           4: ("Phanerozoic sedimentary cover", 1.0)}  # D12: kept at 1.0 but flagged; depth to target unknown
+PHANEROZOIC = "Cambrian|Ordovician|Silurian|Devonian|Mississippian|Pennsylvanian|Permian|Jurassic|Cretaceous|Paleozoic"
+IF_BUFFER_M = 500.0
+
+
+def classify(sgmc: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    g = sgmc.copy()
+    lith = g.GENERALIZED_LITH.fillna("")
+    iron = lith.str.contains("iron formation", case=False) | g.MAJOR1.fillna("").str.contains("iron-formation", case=False)
+    meso = (g.AGE_MIN.fillna("") + g.AGE_MAX.fillna("")).str.contains("Mesoproterozoic")
+    volc = lith.str.contains("volcanic", case=False) & meso
+    intr = lith.str.contains("intrusive", case=False)
+    phan = g.AGE_MIN.fillna("").str.contains(PHANEROZOIC) & lith.str.contains("Sedimentary")
+    g["geo_class"] = np.select([iron, intr, volc, phan], [1, 3, 2, 4], 0)
+    return g
+
+
+def rasterize_classes(g: gpd.GeoDataFrame, transform, shape) -> np.ndarray:
+    """Paint class codes in increasing priority: volcanic, intrusive, then buffered iron formation on top."""
+    out = np.zeros(shape, dtype="uint8")
+    for code in (4, 2, 3):
+        sub = g[g.geo_class == code]
+        if len(sub):
+            out = np.where(rasterize(((geom, 1) for geom in sub.geometry), out_shape=shape,
+                                     transform=transform, fill=0, dtype="uint8") == 1, code, out)
+    iron = g[g.geo_class == 1]
+    if len(iron):
+        m = rasterize(((geom.buffer(IF_BUFFER_M), 1) for geom in iron.geometry), out_shape=shape,
+                      transform=transform, fill=0, dtype="uint8")
+        out[m == 1] = 1
+    return out
+
+
+def multiplier(codes: np.ndarray) -> np.ndarray:
+    lut = np.array([CLASSES[k][1] for k in sorted(CLASSES)], dtype="float32")
+    return lut[codes]

riftprospect-0.1.0/src/riftprospect/geophys.py

@@ -0,0 +1,72 @@
+"""Part B: rule-based geophysical evidence for small mafic-ultramafic intrusions.
+
+Plain-language note: magmatic nickel deposits like Eagle sit in small, dense, magnetic
+intrusions of mafic and ultramafic rock, which are low in potassium and thorium. This file
+turns each airborne measurement into a 0-to-1 "how much does this square look like that"
+score, then combines them with weights. Weights are DECISION D6 (yours). Uncertainty comes
+from re-running with randomly varied weights and transition points (Monte Carlo).
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+# Evidence layers: (column, direction). +1 = higher is more favorable; -1 = lower is.
+# Rationale (to be checked by Bezali, D6):
+#   rtp_asig  : strong magnetic gradients mark discrete magnetic bodies (pyrrhotite/magnetite-bearing intrusions)
+#   rtp_resid : magnetic high relative to the surrounding 2 km
+#   k, th     : mafic-ultramafic rocks are poor in K and Th
+LAYERS = {"rtp_asig": +1, "rtp_resid": +1, "k": -1, "th": -1}
+# DECISION D6: provisional equal-ish weights, magnetics favored because cover attenuates gamma rays.
+WEIGHTS = {"rtp_asig": 0.35, "rtp_resid": 0.35, "k": 0.15, "th": 0.15}
+MIDPOINT_PCT = 75.0   # logistic membership centred at this percentile (direction-adjusted)
+SPREAD_PCT = 10.0
+
+
+def percentile_rank(v: np.ndarray) -> np.ndarray:
+    """0-100 percentile of each value within the survey (NaN stays NaN)."""
+    out = np.full(v.shape, np.nan)
+    ok = ~np.isnan(v)
+    order = v[ok].argsort().argsort()
+    out[ok] = 100.0 * order / max(ok.sum() - 1, 1)
+    return out
+
+
+def membership(pct: np.ndarray, direction: int, mid=MIDPOINT_PCT, spread=SPREAD_PCT) -> np.ndarray:
+    p = pct if direction > 0 else 100.0 - pct
+    return 1.0 / (1.0 + np.exp(-(p - mid) / spread))
+
+
+def evidence(df: pd.DataFrame, by_block: bool = True) -> pd.DataFrame:
+    """Percentile ranks per layer. Ranked within each survey block because the blocks differ
+    in line spacing (150 m vs 400 m) and therefore in how sharp the gradients are."""
+    out = pd.DataFrame(index=df.index)
+    groups = df.groupby("block").groups if by_block else {"all": df.index}
+    for col in LAYERS:
+        r = pd.Series(np.nan, index=df.index)
+        for _, idx in groups.items():
+            r.loc[idx] = percentile_rank(df.loc[idx, col].to_numpy(dtype=float))
+        out[col] = r
+    return out
+
+
+def score(pct: pd.DataFrame, weights=None, mid=MIDPOINT_PCT, spread=SPREAD_PCT) -> np.ndarray:
+    """Weighted mean of memberships; a missing layer is skipped and the weights renormalized."""
+    weights = weights or WEIGHTS
+    num = np.zeros(len(pct)); den = np.zeros(len(pct))
+    for col, d in LAYERS.items():
+        m = membership(pct[col].to_numpy(), d, mid, spread)
+        ok = ~np.isnan(m)
+        num[ok] += weights[col] * m[ok]; den[ok] += weights[col]
+    return num / np.where(den > 0, den, np.nan)
+
+
+def monte_carlo(pct: pd.DataFrame, n: int = 100, seed: int = 0, concentration: float = 20.0):
+    """Mean and SD of the score when weights ~ Dirichlet around WEIGHTS and the midpoint ~ U(65, 85)."""
+    rng = np.random.default_rng(seed)
+    base = np.array([WEIGHTS[c] for c in LAYERS])
+    runs = np.empty((n, len(pct)), dtype="float32")
+    for i in range(n):
+        w = dict(zip(LAYERS, rng.dirichlet(base * concentration)))
+        runs[i] = score(pct, w, mid=rng.uniform(65, 85))
+    return runs.mean(0), runs.std(0)

riftprospect-0.1.0/src/riftprospect/grid.py

@@ -0,0 +1,94 @@
+"""Put airborne geophysical grids from several survey blocks onto one common grid.
+
+Plain-language note: the USGS survey comes as two blocks with different cell sizes.
+This module averages each block onto the same 200 m squares so every square has
+one value per measurement. You do not need to open this file.
+"""
+from __future__ import annotations
+
+import numpy as np
+import rasterio
+from rasterio.enums import Resampling
+from rasterio.transform import from_origin
+from rasterio.warp import reproject
+
+
+def common_transform(bounds_list, cell):
+    """Return (transform, height, width) of a grid that covers all bounds, snapped to `cell`."""
+    left = np.floor(min(b[0] for b in bounds_list) / cell) * cell
+    bottom = np.floor(min(b[1] for b in bounds_list) / cell) * cell
+    right = np.ceil(max(b[2] for b in bounds_list) / cell) * cell
+    top = np.ceil(max(b[3] for b in bounds_list) / cell) * cell
+    width = int(round((right - left) / cell))
+    height = int(round((top - bottom) / cell))
+    return from_origin(left, top, cell, cell), height, width
+
+
+def mosaic_average(paths, transform, shape, crs):
+    """Average-resample each raster in `paths` onto the target grid; later files fill gaps only.
+
+    Returns a float32 array with NaN where no source has data. Each target cell is
+    the mean of the source cells it covers (rasterio Resampling.average), so finer
+    blocks are smoothed, not subsampled.
+    """
+    out = np.full(shape, np.nan, dtype="float32")
+    for p in paths:
+        with rasterio.open(p) as src:
+            src_arr = src.read(1).astype("float32")
+            nod = src.nodata
+            if nod is not None:
+                src_arr[src_arr == nod] = np.nan
+            tmp = np.full(shape, np.nan, dtype="float32")
+            reproject(src_arr, tmp, src_transform=src.transform, src_crs=src.crs,
+                      dst_transform=transform, dst_crs=crs, src_nodata=np.nan,
+                      dst_nodata=np.nan, resampling=Resampling.average)
+        fill = np.isnan(out) & ~np.isnan(tmp)
+        out[fill] = tmp[fill]
+    return out
+
+
+def analytic_signal(field, cell):
+    """Total-gradient (3D analytic signal) amplitude of a potential-field grid.
+
+    Horizontal derivatives by central differences; the vertical derivative by the
+    FFT |k| filter on a NaN-filled copy. Edges within a few cells of data gaps are
+    less reliable; cells that were NaN stay NaN.
+    """
+    f = field.astype("float64")
+    mask = np.isnan(f)
+    fill = np.where(mask, np.nanmean(f), f)
+    dy, dx = np.gradient(fill, cell)
+    ky = np.fft.fftfreq(f.shape[0], d=cell) * 2 * np.pi
+    kx = np.fft.fftfreq(f.shape[1], d=cell) * 2 * np.pi
+    k = np.sqrt(kx[None, :] ** 2 + ky[:, None] ** 2)
+    dz = np.real(np.fft.ifft2(np.fft.fft2(fill - fill.mean()) * k))
+    asig = np.sqrt(dx ** 2 + dy ** 2 + dz ** 2)
+    asig[mask] = np.nan
+    return asig.astype("float32")
+
+
+def local_std(field, radius_cells):
+    """Standard deviation in a square window (2r+1 cells), ignoring NaN. A texture measure."""
+    from scipy.ndimage import uniform_filter
+    f = field.astype("float64")
+    valid = ~np.isnan(f)
+    z = np.where(valid, f, 0.0)
+    size = 2 * radius_cells + 1
+    n = uniform_filter(valid.astype("float64"), size)
+    m1 = uniform_filter(z, size) / np.where(n > 0, n, np.nan)
+    m2 = uniform_filter(z * z, size) / np.where(n > 0, n, np.nan)
+    sd = np.sqrt(np.clip(m2 - m1 ** 2, 0, None))
+    sd[~valid] = np.nan
+    return sd.astype("float32")
+
+
+def local_mean(field, radius_cells):
+    """Mean in a square window (2r+1 cells), ignoring NaN."""
+    from scipy.ndimage import uniform_filter
+    f = field.astype("float64")
+    valid = ~np.isnan(f)
+    size = 2 * radius_cells + 1
+    n = uniform_filter(valid.astype("float64"), size)
+    m = uniform_filter(np.where(valid, f, 0.0), size) / np.where(n > 0, n, np.nan)
+    m[~valid] = np.nan
+    return m.astype("float32")

riftprospect-0.1.0/src/riftprospect.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: riftprospect
+Version: 0.1.0
+Summary: Open prospectivity modeling for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift
+Author: Bezali Kwame Danso
+License: MIT
+Project-URL: Source, https://github.com/bkdanso/riftprospect
+Keywords: mineral prospectivity,critical minerals,nickel,platinum-group elements,Midcontinent Rift,geochemistry,aeromagnetics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-DATA.md
+License-File: AUTHORS.json
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: rasterio>=1.3
+Requires-Dist: geopandas>=0.14
+Requires-Dist: pyproj>=3.5
+Requires-Dist: pyarrow>=12
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# riftprospect: open prospectivity model for magmatic Ni-Cu-Co-PGE in the Midcontinent Rift
+
+**Status:** Released | v0.1.0 | built 2026-10-27 | **Software DOI:** [10.5281/zenodo.23697827](https://doi.org/10.5281/zenodo.23697827) | **Target table DOI:** [10.5281/zenodo.23697829](https://doi.org/10.5281/zenodo.23697829) | **Map:** [https://bkdanso.github.io/riftprospect/](https://bkdanso.github.io/riftprospect/) | **Maintainer:** Bezali Kwame Danso ([ORCID](https://orcid.org/0009-0006-1201-4129)) | Code MIT, data CC BY-SA 4.0
+
+**In plain terms:** Nickel, cobalt, copper and the platinum-group metals are on the 2025 U.S. critical minerals list. The Eagle mine near Marquette, Michigan, is the only U.S. mine that produces nickel as its main product, and the rock around Lake Superior could hold more deposits like it, mostly hidden under glacial sediment. This project turns free public data into a ranked list of places worth checking. It scores every 200 m square of the 2025 USGS airborne survey of the Upper Peninsula and northern Wisconsin (39,368.6 km², 984,215 squares) by how much its magnetism and natural radioactivity look like the small, dense, magnetic intrusions that host deposits like Eagle. It also tests which rock-chemistry signals actually tell you a deposit is nearby. The Eagle mine was held out of every fitting step. It still ranks at the **98.86th percentile** of the survey area.
+
+New here? Read [docs/START_HERE.md](docs/START_HERE.md). Terms are explained in [docs/GLOSSARY.md](docs/GLOSSARY.md).
+
+![Prospectivity map](paper/figures/fig3_prospectivity.png)
+
+## What it found (validation study)
+
+| Test | Result |
+|---|---|
+| Held-out Eagle mine, final score | 98.86th percentile; captured within the top 1.14% of the area |
+| Eagle, range across 200 random weightings | 97.6th to 98.77th percentile |
+| Eagle, magnetics only / radiometrics only | 95.6th / 88.44th percentile |
+| Chemistry model (Ni/Cu, MgO, Mg-number), spatial cross-validation in Minnesota | AUC 0.29 with near = 3 km (0.48 at 2 km, 0.35 at 5 km; 0.5 = chance): **does not discriminate, and is unstable** |
+| Cu/Pd within 3 km of a deposit vs more than 10 km away (igneous rocks) | median 21,736 vs 31,568 (n = 330 vs 138) |
+| Targets (top 2% of non-edge squares) | 1,629 targets covering 751.8 km² |
+
+Interpretation and caveats: [docs/LIMITATIONS.md](docs/LIMITATIONS.md). Every modeling choice: [docs/DECISIONS.md](docs/DECISIONS.md).
+
+## Interactive map
+
+Open it at **https://bkdanso.github.io/riftprospect/**. The source is `site/`, a static Leaflet map: score, uncertainty, the 1,629 targets with popups, known deposits, and Cu/Pd sample labels.
+
+## Install and use
+
+```
+pip install riftprospect
+riftprospect fertility my_samples.csv > fertility.csv
+```
+
+`my_samples.csv` needs columns `Cu_ppm, Ni_ppm, Pd_ppb, Pt_ppb, MgO_wt, Fe2O3T_wt` (negative = below detection, as in MCR-GeoChem). Output: Cu/Pd, Ni/Cu, Pd/Pt, Mg-number and a Cu/Pd fertility class per sample.
+
+## Rebuild everything
+
+```
+./run_all.sh            # about 1 GB of downloads; about 10 minutes
+```
+
+Expected: `paper/stats.json` with 984,215 cells, Eagle at the 98.86th percentile, 1,629 targets, and 14 passing tests.
+
+## Pipeline
+
+| Script | Does |
+|---|---|
+| `01_fetch.py`, `01b_fetch_sgmc.py` | Download all sources; log size and SHA-256 to `data/raw/PROVENANCE.txt` |
+| `02_grid.py` | Average the two survey blocks onto one 200 m grid; analytic signal, residual field, edge distance |
+| `03_fertility.py` | Cu/Pd, Ni/Cu, MgO, Mg-number per sample |
+| `05_chem_model.py` | Part A: chemistry model trained in Minnesota, spatial cross-validation (reported, not used on the map) |
+| `06_geophys.py` | Part B: rule-based geophysics score with Monte Carlo uncertainty |
+| `08_combine.py` | Geology mask, targets, held-out Eagle test |
+| `09_validate.py` | All validation numbers into `paper/stats.json` |
+| `04`, `07`, `10` | Figures and the web map |
+
+## Outputs
+
+| File | One row is |
+|---|---|
+| `data/processed/targets_ranked.csv` | one target: location, area, peak and mean score, uncertainty, mapped geology, nearby Cu/Pd label |
+| `data/processed/prospectivity_cells.parquet` | one 200 m square with every evidence layer and score |
+| `data/processed/sample_scores.csv` | one rock sample with indicators and chemistry-model score |
+| `paper/stats.json` | every number quoted anywhere |
+
+Column definitions: [docs/CODEBOOK.md](docs/CODEBOOK.md).
+
+## Sources
+
+| Source | Vintage | License |
+|---|---|---|
+| USGS Critical Mineral Deposits of the United States (Hammarstrom, Woodruff, Dicken and Zach), [doi:10.5066/P9K1HBNT](https://doi.org/10.5066/P9K1HBNT) | ver. 3.0, Sept 2026 | CC0 |
+| USGS Airborne magnetic and radiometric survey, Upper Peninsula, Michigan, and parts of northern Wisconsin, 2025 (Drenth, Murchek, Brown and Connell), [doi:10.5066/P14ESDF7](https://doi.org/10.5066/P14ESDF7) | released Sept 2026 | Public domain |
+| MCR-GeoChem (Danso and Abdullah), [doi:10.5281/zenodo.23516434](https://doi.org/10.5281/zenodo.23516434) | v1.0.1, Oct 2026 | CC BY-SA 4.0 |
+| USGS State Geologic Map Compilation (Horton, San Juan and Stoeser), [doi:10.3133/ds1052](https://doi.org/10.3133/ds1052) | 2017 | Public domain |
+
+## Cite
+
+Software: Danso, B.K. (2026). riftprospect v0.1.0: open prospectivity model for magmatic Ni-Cu-Co-PGE deposits in the Midcontinent Rift. Zenodo. https://doi.org/10.5281/zenodo.23697827
+
+Target table: Danso, B.K. (2026). Ranked prospectivity targets for magmatic Ni-Cu-Co-PGE deposits, Upper Peninsula of Michigan and northern Wisconsin (v0.1.0). Zenodo. https://doi.org/10.5281/zenodo.23697829
+
+See also `CITATION.cff`. Please also cite the sources above.
+
+## AI assistance
+
+Claude (Anthropic) assisted with code, tests and drafting. Bezali Kwame Danso made every modeling decision (docs/DECISIONS.md) and verified the outputs.

riftprospect-0.1.0/src/riftprospect.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+AUTHORS.json
+LICENSE
+LICENSE-DATA.md
+README.md
+pyproject.toml
+src/riftprospect/__init__.py
+src/riftprospect/chemmodel.py
+src/riftprospect/cli.py
+src/riftprospect/combine.py
+src/riftprospect/fertility.py
+src/riftprospect/geology.py
+src/riftprospect/geophys.py
+src/riftprospect/grid.py
+src/riftprospect.egg-info/PKG-INFO
+src/riftprospect.egg-info/SOURCES.txt
+src/riftprospect.egg-info/dependency_links.txt
+src/riftprospect.egg-info/entry_points.txt
+src/riftprospect.egg-info/requires.txt
+src/riftprospect.egg-info/top_level.txt
+tests/test_core.py

riftprospect-0.1.0/src/riftprospect.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

riftprospect-0.1.0/src/riftprospect.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+riftprospect = riftprospect.cli:main

riftprospect-0.1.0/src/riftprospect.egg-info/requires.txt

@@ -0,0 +1,13 @@
+numpy>=1.24
+pandas>=2.0
+scipy>=1.10
+scikit-learn>=1.3
+rasterio>=1.3
+geopandas>=0.14
+pyproj>=3.5
+pyarrow>=12
+openpyxl>=3.1
+matplotlib>=3.7
+
+[test]
+pytest>=7

riftprospect-0.1.0/src/riftprospect.egg-info/top_level.txt

@@ -0,0 +1 @@
+riftprospect

riftprospect-0.1.0/tests/test_core.py

@@ -0,0 +1,93 @@
+"""Tests for riftprospect. Hand-checkable numbers; run with `pytest`."""
+import numpy as np
+import pandas as pd
+import pytest
+from affine import Affine
+
+from riftprospect import fertility as fe, geophys as gp, combine as cb, chemmodel as cm, geology as geo
+from riftprospect.grid import common_transform, local_mean, analytic_signal
+
+
+def wide(**kw):
+    base = dict(mcr_uid=["a"], Cu_ppm=[100.0], Ni_ppm=[200.0], Pd_ppb=[10.0], Pt_ppb=[5.0], MgO_wt=[10.0], Fe2O3T_wt=[12.0])
+    base.update(kw); return pd.DataFrame(base)
+
+
+def test_cu_pd_units():
+    # Cu 100 ppm, Pd 10 ppb = 0.01 ppm -> Cu/Pd = 10,000
+    assert fe.indicators(wide()).cu_pd.iloc[0] == pytest.approx(10000)
+
+
+def test_ni_cu_and_pd_pt():
+    r = fe.indicators(wide()).iloc[0]
+    assert r.ni_cu == pytest.approx(2.0) and r.pd_pt == pytest.approx(2.0)
+
+
+def test_mg_number_by_hand():
+    # MgO 10 / 40.304 = 0.24811 mol; FeT = 2*12/159.688 = 0.15030; Fe2+ = 0.9*0.15030 = 0.13527
+    assert fe.mg_number(10.0, 12.0) == pytest.approx(100 * 0.24811 / (0.24811 + 0.13527), rel=1e-3)
+
+
+def test_censored_drop_and_half():
+    d = wide(Pd_ppb=[-2.0])  # below detection, limit 2 ppb
+    assert np.isnan(fe.indicators(d, rule="drop").cu_pd.iloc[0])
+    h = fe.indicators(d, rule="half").iloc[0]
+    assert h.cu_pd == pytest.approx(100 / 0.001) and bool(h.cu_pd_censored)
+
+
+def test_cu_pd_classes():
+    c = fe.cu_pd_class(pd.Series([1000.0, 7000.0, 50000.0, np.nan]))
+    assert list(c) == ["pge_enriched", "mantle_like", "pge_depleted", "undetermined"]
+
+
+def test_membership_direction():
+    assert gp.membership(np.array([95.0]), +1)[0] > 0.8
+    assert gp.membership(np.array([95.0]), -1)[0] < 0.2
+
+
+def test_percentile_rank_keeps_nan():
+    r = gp.percentile_rank(np.array([3.0, np.nan, 1.0, 2.0]))
+    assert np.isnan(r[1]) and r[2] == 0 and r[0] == 100
+
+
+def test_score_renormalizes_missing_layer():
+    pct = pd.DataFrame({"rtp_asig": [100.0], "rtp_resid": [100.0], "k": [np.nan], "th": [np.nan]})
+    s = gp.score(pct)[0]
+    assert s == pytest.approx(gp.membership(np.array([100.0]), 1)[0])
+
+
+def test_common_transform_snaps():
+    tr, h, w = common_transform([(10, 10, 390, 190)], 200)
+    assert (tr.c, tr.f, h, w) == (0, 200, 1, 2)
+
+
+def test_local_mean_flat_field():
+    f = np.ones((7, 7), "float32"); f[0, 0] = np.nan
+    m = local_mean(f, 1)
+    assert np.isnan(m[0, 0]) and m[3, 3] == pytest.approx(1)
+
+
+def test_analytic_signal_constant_is_zero():
+    a = analytic_signal(np.full((16, 16), 5.0), 200)
+    assert np.nanmax(a) == pytest.approx(0, abs=1e-9)
+
+
+def test_targets_edge_and_ranking():
+    grid = pd.DataFrame({"row": [0, 0, 1, 2], "col": [0, 1, 1, 3], "cell_id": list("abcd"), "x": [0, 1, 1, 3.0], "y": [0, 0, 1, 2.0],
+                         "score": [0.9, 0.8, 0.1, 0.95], "score_sd": [0.1] * 4, "edge_dist_m": [5000, 5000, 5000, 100],
+                         "evidence": ["g"] * 4, "block": ["A"] * 4})
+    t, lab = cb.targets(grid, (3, 4), top_pct=50, min_cells=1)
+    assert len(t) == 1 and t.n_cells.iloc[0] == 2   # the edge cell (d) is excluded
+    assert lab[2, 3] == 0
+
+
+def test_training_table_buffer_excluded():
+    df = pd.DataFrame({"rock_class": ["igneous_intrusive"] * 3, "altered_likely": [False] * 3,
+                       "ni_cu": [1, 1, 1.0], "cu_pd": [1, 1, 1.0], "MgO_wt": [5, 5, 5.0], "mg_number": [50, 50, 50.0],
+                       "dep_km": [1.0, 5.0, 20.0]})
+    t = cm.training_table(df)
+    assert list(t.label) == [1, 0]
+
+
+def test_geology_multiplier():
+    assert list(geo.multiplier(np.array([0, 1, 2, 3, 4], "uint8"))) == pytest.approx([1.0, 0.3, 0.6, 1.0, 1.0])