Stock-and-Flow Modeling of Resource Depletion: A Systems Modeling Case Study

Last Updated June 7, 2026

Stock-and-flow modeling of resource depletion shows how a system can appear stable while its underlying resource base is quietly being exhausted. A forest, fishery, aquifer, mineral deposit, soil reserve, battery material supply, public budget, data-center energy capacity, or institutional workforce can all be understood as a stock: an accumulation that rises through inflows and falls through outflows. The central question is not simply how much is being used now. The deeper question is whether extraction, regeneration, discovery, substitution, conservation, and demand interact in a way that preserves the stock, slowly depletes it, or drives overshoot and collapse.

This case study builds a practical stock-and-flow model of a renewable resource under extraction pressure. It starts with a simple resource stock, adds regeneration, adds demand growth, adds extraction limits, adds price or scarcity feedback, adds conservation response, and then compares scenarios. The purpose is not to predict a real forest, fishery, aquifer, or mineral system. The purpose is to demonstrate how formal stock-and-flow structure helps reveal accumulation, delay, overshoot, depletion, rebound, threshold risk, and policy leverage.

Resource depletion is often misunderstood because people focus on annual extraction rather than stock behavior. A system can maintain high output for years while the underlying stock declines. It can appear productive because extraction technology improves, markets remain supplied, or inventories buffer scarcity. But if the outflow persistently exceeds the inflow, the stock falls. If regeneration depends on the remaining stock, depletion can weaken recovery. If scarcity feedback arrives late, the system may overshoot before corrective action becomes politically, economically, or ecologically effective.

This article works through the case as a model-building exercise. It identifies the stock, flows, feedback loops, governing equations, assumptions, parameters, scenarios, diagnostics, uncertainty, interpretation limits, and responsible communication requirements. It also includes R and Python workflows that simulate depletion pathways and export reproducible scenario tables.

This case study covers model purpose, stock identification, inflows, outflows, regeneration, extraction, demand growth, feedback loops, assumptions, equations, scenarios, simulation logic, depletion diagnostics, threshold risk, policy leverage, uncertainty, interpretation limits, R and Python workflows, responsible communication, and references for further study.

Case Study Purpose

The purpose of this case study is to show how a stock-and-flow model can clarify resource depletion dynamics. The model is intentionally simple enough to inspect, reproduce, modify, and explain. It is not a full ecological, economic, geological, hydrological, or industrial model. It is a structured learning model for examining how a resource stock changes over time when extraction, regeneration, demand, scarcity feedback, and conservation interact.

The case is written as a generic renewable-resource model. The same structure can be adapted to a fishery, forest, aquifer, grazing system, soil nutrient stock, biomass reserve, or other replenishable resource. With changes to regeneration and discovery assumptions, the same modeling logic can also inform nonrenewable resource cases such as minerals, fossil fuels, or finite material reserves.

This case should be read as a worked example of model structure. The exact numerical results depend on chosen parameters, but the system logic is widely relevant: if a stock is depleted faster than it is replenished, the system eventually confronts scarcity, collapse risk, or forced adaptation.

Back to top ↑

The System Being Modeled

The modeled system is a resource base used by a human or institutional system. The resource stock has a maximum carrying capacity, a natural regeneration process, and an extraction process driven by demand. Extraction satisfies demand while the stock remains large enough, but extraction becomes constrained when the stock declines. A conservation response can reduce demand or extraction pressure, but that response may be weak, delayed, or triggered only after scarcity becomes visible.

The case can be interpreted as a stylized forest where biomass regrows, a fishery where population regenerates, an aquifer where recharge replenishes groundwater, or a managed resource pool where withdrawals compete with renewal. The details differ by domain, but the stock-and-flow structure is similar: resource stock rises through regeneration and falls through extraction.

The model is deliberately abstract. That abstraction is useful because it lets the case focus on depletion structure before adding domain-specific details. A real-world model would require site-specific data, stakeholder review, ecological or geological evidence, institutional context, and validation against observed patterns.

Back to top ↑

Why Resource Depletion Needs Stock-and-Flow Thinking

Resource depletion is a stock problem. It cannot be understood from current extraction alone. A society may extract 100 units per year, 1 million barrels per day, 10 billion cubic meters per year, or 2 percent of a forest annually, but those flow values only become meaningful when compared with the size of the stock, the rate of replenishment, the time horizon, and the feedback response.

Stock-and-flow thinking matters because stocks create memory. A resource stock reflects past regeneration, past extraction, past stress, past management, and past delay. If extraction exceeds regeneration for many years, the system carries that history as depletion. Even if extraction later slows, the stock may take decades to recover, and in some systems recovery may fail after thresholds are crossed.

A stock-and-flow model therefore shifts attention from “How much can we extract this year?” to “What does this extraction pathway do to the stock, recovery capacity, and future options?”

Back to top ↑

Core Stock-and-Flow Structure

The core structure has one stock and two primary flows. The stock is the resource base. The inflow is regeneration. The outflow is extraction. If regeneration exceeds extraction, the stock grows. If extraction exceeds regeneration, the stock falls. If the two flows balance, the stock stabilizes.

The simplest discrete-time update is:

This basic equation is the heart of the case. Every scenario is a different story about how \(G_t\), \(E_t\), and \(D_t\) behave over time.

Back to top ↑

Conceptual Model

The conceptual model links ecological or physical renewal with human demand. When the resource stock is high, regeneration is strong and extraction can satisfy demand. As the resource stock declines, regeneration can weaken, scarcity pressure can increase, and extraction may become harder or more costly. If scarcity response is early and strong, the system may stabilize. If demand growth continues and conservation is delayed, the system can overshoot.

The conceptual model is intentionally transparent. It is easier to inspect than a large integrated assessment model or a domain-specific ecological simulation. That transparency is valuable for learning because the user can see why the system stabilizes or depletes.

Back to top ↑

Main Feedback Loops

The case includes several feedback loops. Some stabilize the system. Others intensify depletion. The most important dynamic is the interaction between extraction growth and scarcity response.

These feedback loops are why resource depletion often feels counterintuitive. The system can produce growth, stability, and scarcity signals at different times, depending on which loops dominate.

Back to top ↑

Model Boundary

The model boundary includes the resource stock, regeneration, extraction, demand, scarcity feedback, conservation response, and simple technology efficiency. It excludes detailed market structure, political institutions, multiple resource classes, geographic variation, ecological food webs, property rights, trade, illegal extraction, distributional effects, and social conflict. Those exclusions are not unimportant. They are left outside the boundary to keep the case focused on stock-and-flow depletion logic.

For a real decision, the boundary would need to expand. A water-resource model might include geography, rights, recharge zones, climate variability, agriculture, urban use, infrastructure, and regulatory enforcement. A fishery model might include age classes, fleets, markets, illegal catch, food-web effects, and community dependence. A forest model might include species, land tenure, fire, biodiversity, soil, carbon, and Indigenous governance.

Back to top ↑

Variables and Parameters

The model uses a small set of variables and parameters. The goal is interpretability. Each parameter has a clear role in the depletion story.

These variables are enough to generate several important behaviors: sustainable equilibrium, gradual depletion, overshoot, delayed scarcity response, and threshold crossing. More complex models can add age structure, spatial layers, multiple sectors, price systems, regulation, shocks, or stakeholder groups.

Back to top ↑

Baseline Assumptions

The baseline assumptions define the initial case. They should be treated as modeling choices, not facts. In real work, each would require evidence, calibration, and review.

These assumptions are intentionally simple. They support learning. They should not be presented as sufficient for real-world allocation, regulation, or extraction policy.

Back to top ↑

Governing Equations

The case uses discrete-time equations. Each period, the model calculates demand, scarcity, conservation, regeneration, extraction, and updated stock.

These equations are simple enough to inspect, but they generate rich behavior. They show how growth in demand can overwhelm regeneration, how conservation can stabilize the system, and how delayed response can allow depletion before corrective action becomes strong enough.

Back to top ↑

Scenario Design

Scenario design asks how the system behaves under different assumptions. In this case, scenarios change demand growth, conservation response, extraction efficiency, regeneration stress, and threshold sensitivity. Each scenario is a structured experiment.

Scenarios should not be treated as predictions. They are conditional experiments. Their value lies in revealing how model structure responds when assumptions change.

Back to top ↑

Baseline Scenario

The baseline scenario starts with a healthy but not full resource stock. Demand grows gradually. Regeneration follows logistic growth. Conservation increases only when the stock falls below the reference level. The scenario asks whether moderate demand growth can coexist with renewal.

In many baseline runs, the system may decline slowly rather than collapse immediately. That slow decline is important. It shows how early depletion can be politically invisible if extraction remains adequate and scarcity has not yet become severe. The model’s value is to make that hidden trajectory visible.

Back to top ↑

High-Demand Scenario

The high-demand scenario increases demand growth. This scenario represents population growth, export pressure, industrial expansion, higher consumption, agricultural intensification, or new technology that increases resource use. The stock may remain productive for a while, but the extraction outflow grows faster than regeneration can compensate.

The high-demand scenario demonstrates why demand growth is often the hidden driver of depletion. Even a renewable resource can behave like a finite resource if extraction growth outruns replenishment long enough.

Back to top ↑

Conservation Scenario

The conservation scenario strengthens the balancing loop. Conservation can mean reduced consumption, quotas, extraction caps, protected areas, seasonal restrictions, water-saving practices, efficiency standards, demand management, restoration programs, or social norms that reduce extraction pressure. In the model, conservation lowers effective demand as scarcity rises.

The conservation scenario often shows that earlier action matters more than emergency action. A modest conservation response before severe depletion may outperform a stronger response that arrives after the stock has already crossed a critical threshold.

Back to top ↑

Technology Efficiency Scenario

Technology can reduce resource pressure, but its effect is ambiguous. More efficient irrigation, fishing gear, logging equipment, recycling, material substitution, or energy systems can reduce extraction per unit of service. But technology can also increase total extraction by lowering cost, expanding access, or enabling deeper exploitation of the stock.

The technology efficiency scenario therefore tests two possibilities: efficiency without rebound and efficiency with rebound. In the first case, technology reduces effective demand. In the second case, efficiency increases access or lowers cost, allowing total use to grow.

The case warns against treating technology as an automatic solution. Whether efficiency stabilizes a resource system depends on demand response, governance, rebound effects, and whether extraction caps or conservation policies are present.

Back to top ↑

Regeneration Stress Scenario

The regeneration stress scenario lowers the regeneration rate. This represents climate stress, habitat degradation, soil erosion, pollution, invasive species, aquifer recharge decline, forest fire, ecosystem fragmentation, or other forces that weaken renewal. The same demand pathway becomes more dangerous when regeneration declines.

This scenario is important because resource depletion is rarely caused by extraction alone. Many real systems face combined stress: rising demand, weaker regeneration, climate variability, governance delay, and uneven access to alternatives.

Back to top ↑

Threshold and Collapse Risk

Threshold risk occurs when the system changes qualitatively after the resource stock falls below a critical level. In a fishery, reproduction may collapse when the breeding population becomes too small. In a forest, regeneration may fail after soil, moisture, or species composition shifts. In an aquifer, saltwater intrusion or compaction may create long-term damage. In a social resource system, trust, workforce capacity, or institutional knowledge may not recover once depleted.

The simplified model flags severe depletion when the stock falls below a threshold fraction of carrying capacity. A more advanced model could make regeneration decline sharply below that threshold.

The threshold diagnostic helps prevent a common mistake: assuming that reducing extraction after collapse begins is the same as preventing collapse before it begins. Timing matters.

Back to top ↑

Diagnostics and Output Measures

The model should not report only final stock. A useful depletion case study needs multiple diagnostics because different outputs answer different questions.

A scenario with high cumulative extraction may look attractive if output is the only metric. But if it also produces low final stock, high unmet demand, and threshold crossing, the model tells a different story: short-term extraction has been purchased by long-term depletion.

Back to top ↑

Interpretation of Results

The model results should be interpreted as behavior patterns, not precise predictions. The most important result is whether the system stabilizes, depletes gradually, overshoots, or collapses under different assumptions. The timing and exact numbers depend on parameter choices.

The interpretation should focus on mechanism: what caused the pattern? Was depletion driven by demand growth, weak regeneration, delayed conservation, extraction capacity, technology rebound, or threshold behavior?

Back to top ↑

Policy Leverage Points

The case reveals several leverage points. Some are direct, such as reducing extraction. Others are structural, such as changing demand growth, monitoring thresholds, or protecting regeneration capacity.

The most powerful intervention is often not emergency restriction after collapse begins. It is early feedback: monitoring the stock, acknowledging uncertainty, and responding before depletion becomes severe.

Back to top ↑

Uncertainty and Sensitivity

Resource depletion models are sensitive to assumptions about regeneration, demand growth, extraction efficiency, conservation response, thresholds, and time horizon. Responsible interpretation requires sensitivity analysis. A model should not present one parameter set as reality.

If the model conclusion changes dramatically under plausible parameter variation, the conclusion should be communicated as fragile. Fragility is not a failure. It is useful information about where evidence and governance matter most.

Back to top ↑

Model Limitations

This case study is intentionally simplified. It is useful for explaining depletion dynamics, but it should not be used as a real resource-management model without major extensions.

The model is therefore best used for learning, scenario exploration, teaching, early conceptual design, and assumption discussion. Real decision support requires domain-specific expansion and validation.

Back to top ↑

Relationship to Other Systems Modeling Approaches

This stock-and-flow case can connect with other modeling approaches. Resource depletion is rarely only a stock problem. It can involve networks, agents, spatial patterns, economic feedback, governance, and uncertainty.

The stock-and-flow model is the foundation. More advanced approaches can add realism, but they should preserve the core accounting discipline: stocks change through flows.

Back to top ↑

Mathematical Lens: Resource Stock, Extraction, Regeneration, and Overshoot

The central stock-and-flow identity is:

A renewable resource can be modeled with logistic regeneration:

Extraction can be constrained by both demand and resource availability:

Overshoot occurs when extraction exceeds regeneration:

A sustainable condition requires extraction to remain at or below regeneration over the relevant time horizon:

A depletion ratio summarizes stock loss:

A threshold indicator can flag severe depletion:

These equations create the analytical backbone of the case. They are simple enough to explain, but powerful enough to reveal depletion pathways.

Back to top ↑

Back to top ↑

R Workflow: Resource Depletion Scenario Simulation

The R workflow below uses base R only. It simulates several resource-depletion scenarios, calculates diagnostics, and exports tables and a simple figure.

# stock_flow_resource_depletion_workflow.R
# Base R workflow:
# resource stock, regeneration, extraction, conservation, and depletion diagnostics.
#
# Suggested repository placement:
# articles/case-study-stock-and-flow-modeling-of-resource-depletion/r/stock_flow_resource_depletion_workflow.R

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- normalizePath(getwd(), mustWork = TRUE)
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

simulate_resource <- function(
  scenario,
  periods = 80,
  carrying_capacity = 100,
  initial_stock = 80,
  regeneration_rate = 0.08,
  initial_demand = 4,
  demand_growth = 0.015,
  extraction_efficiency = 0.12,
  conservation_sensitivity = 0.45,
  max_conservation = 0.35,
  reference_stock_fraction = 0.70,
  critical_threshold_fraction = 0.20
) {
  stock <- numeric(periods + 1)
  stock[1] <- initial_stock

  rows <- data.frame()

  reference_stock <- reference_stock_fraction * carrying_capacity
  critical_threshold <- critical_threshold_fraction * carrying_capacity

  for (t in 0:(periods - 1)) {
    current_stock <- stock[t + 1]

    demand <- initial_demand * (1 + demand_growth) ^ t
    scarcity <- max(0, 1 - current_stock / reference_stock)
    conservation <- min(max_conservation, conservation_sensitivity * scarcity)

    effective_demand <- demand * (1 - conservation)
    regeneration <- regeneration_rate * current_stock * (1 - current_stock / carrying_capacity)
    extraction_capacity <- extraction_efficiency * current_stock
    extraction <- min(effective_demand, extraction_capacity, current_stock + regeneration)
    unmet_demand <- max(0, demand - extraction)

    next_stock <- max(0, current_stock + regeneration - extraction)
    stock[t + 2] <- next_stock

    rows <- rbind(
      rows,
      data.frame(
        scenario = scenario,
        time = t,
        resource_stock = current_stock,
        demand = demand,
        scarcity = scarcity,
        conservation = conservation,
        regeneration = regeneration,
        extraction = extraction,
        unmet_demand = unmet_demand,
        critical_threshold = critical_threshold,
        below_critical_threshold = current_stock < critical_threshold
      )
    )
  }

  rows
}

scenarios <- list(
  baseline = list(demand_growth = 0.015, regeneration_rate = 0.08, conservation_sensitivity = 0.45, max_conservation = 0.35),
  high_demand = list(demand_growth = 0.035, regeneration_rate = 0.08, conservation_sensitivity = 0.45, max_conservation = 0.35),
  conservation = list(demand_growth = 0.015, regeneration_rate = 0.08, conservation_sensitivity = 0.85, max_conservation = 0.55),
  technology_rebound = list(demand_growth = 0.030, regeneration_rate = 0.08, extraction_efficiency = 0.18, conservation_sensitivity = 0.35, max_conservation = 0.30),
  regeneration_stress = list(demand_growth = 0.015, regeneration_rate = 0.045, conservation_sensitivity = 0.45, max_conservation = 0.35),
  delayed_governance = list(demand_growth = 0.025, regeneration_rate = 0.08, conservation_sensitivity = 0.20, max_conservation = 0.20)
)

all_runs <- data.frame()

for (scenario_name in names(scenarios)) {
  params <- scenarios[[scenario_name]]

  run <- do.call(
    simulate_resource,
    c(list(scenario = scenario_name), params)
  )

  all_runs <- rbind(all_runs, run)
}

scenario_names <- unique(all_runs$scenario)
summary_rows <- data.frame()

for (scenario_name in scenario_names) {
  subset_rows <- all_runs[all_runs$scenario == scenario_name, ]

  threshold_times <- subset_rows$time[subset_rows$below_critical_threshold]

  threshold_crossing_time <- ifelse(
    length(threshold_times) == 0,
    NA,
    min(threshold_times)
  )

  initial_stock <- subset_rows$resource_stock[1]
  final_stock <- subset_rows$resource_stock[nrow(subset_rows)]

  summary_rows <- rbind(
    summary_rows,
    data.frame(
      scenario = scenario_name,
      initial_stock = initial_stock,
      final_stock = final_stock,
      minimum_stock = min(subset_rows$resource_stock),
      depletion_ratio = 1 - final_stock / initial_stock,
      cumulative_extraction = sum(subset_rows$extraction),
      cumulative_regeneration = sum(subset_rows$regeneration),
      cumulative_unmet_demand = sum(subset_rows$unmet_demand),
      threshold_crossing_time = threshold_crossing_time
    )
  )
}

validation_checks <- data.frame(
  check = c(
    "scenario_runs_created",
    "resource_stock_nonnegative",
    "extraction_nonnegative",
    "regeneration_nonnegative",
    "summary_created"
  ),
  passed = c(
    nrow(all_runs) > 0,
    all(all_runs$resource_stock >= 0),
    all(all_runs$extraction >= 0),
    all(all_runs$regeneration >= 0),
    nrow(summary_rows) > 0
  )
)

write.csv(
  all_runs,
  file.path(tables_dir, "r_resource_depletion_scenario_timeseries.csv"),
  row.names = FALSE
)

write.csv(
  summary_rows,
  file.path(tables_dir, "r_resource_depletion_scenario_summary.csv"),
  row.names = FALSE
)

write.csv(
  validation_checks,
  file.path(tables_dir, "r_resource_depletion_validation_checks.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_resource_stock_scenarios.png"), width = 1000, height = 700)
plot(
  NULL,
  xlim = range(all_runs$time),
  ylim = c(0, 100),
  xlab = "Time",
  ylab = "Resource Stock",
  main = "Stock-and-Flow Resource Depletion Scenarios"
)

for (scenario_name in scenario_names) {
  subset_rows <- all_runs[all_runs$scenario == scenario_name, ]
  lines(subset_rows$time, subset_rows$resource_stock, lwd = 2)
}

legend("topright", legend = scenario_names, lwd = 2, cex = 0.75)
grid()
dev.off()

print(summary_rows)
print(validation_checks)
cat("R stock-and-flow resource depletion workflow complete.\n")

This workflow shows how a small stock-and-flow model can generate scenario tables, threshold diagnostics, and time-series outputs without requiring specialized software.

Back to top ↑

Python Workflow: Stock-and-Flow Resource Depletion Model

The Python workflow below uses only the standard library. It simulates a resource stock under several scenarios and exports time-series, summary, parameter, and validation tables.

#!/usr/bin/env python3
"""
Case study: stock-and-flow modeling of resource depletion.

Dependency-light workflow demonstrating:

1. Resource stock simulation
2. Regeneration and extraction flows
3. Demand growth
4. Scarcity-triggered conservation
5. Scenario comparison
6. Depletion diagnostics and validation checks

All data are synthetic.
"""

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
import math
from typing import Optional


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass(frozen=True)
class Scenario:
    name: str
    periods: int = 80
    carrying_capacity: float = 100.0
    initial_stock: float = 80.0
    regeneration_rate: float = 0.08
    initial_demand: float = 4.0
    demand_growth: float = 0.015
    extraction_efficiency: float = 0.12
    conservation_sensitivity: float = 0.45
    max_conservation: float = 0.35
    reference_stock_fraction: float = 0.70
    critical_threshold_fraction: float = 0.20


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")

    fieldnames: list[str] = []
    for row in rows:
        for key in row:
            if key not in fieldnames:
                fieldnames.append(key)

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def simulate(scenario: Scenario) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    stock = scenario.initial_stock
    reference_stock = scenario.reference_stock_fraction * scenario.carrying_capacity
    critical_threshold = scenario.critical_threshold_fraction * scenario.carrying_capacity

    for time in range(scenario.periods):
        demand = scenario.initial_demand * ((1.0 + scenario.demand_growth) ** time)
        scarcity = max(0.0, 1.0 - stock / max(reference_stock, 1e-9))
        conservation = min(
            scenario.max_conservation,
            scenario.conservation_sensitivity * scarcity,
        )

        effective_demand = demand * (1.0 - conservation)

        regeneration = (
            scenario.regeneration_rate
            * stock
            * (1.0 - stock / scenario.carrying_capacity)
        )
        regeneration = max(0.0, regeneration)

        extraction_capacity = scenario.extraction_efficiency * stock
        extraction = min(effective_demand, extraction_capacity, stock + regeneration)
        unmet_demand = max(0.0, demand - extraction)

        next_stock = max(0.0, stock + regeneration - extraction)

        rows.append({
            "scenario": scenario.name,
            "time": time,
            "resource_stock": round(stock, 6),
            "demand": round(demand, 6),
            "scarcity": round(scarcity, 6),
            "conservation": round(conservation, 6),
            "regeneration": round(regeneration, 6),
            "extraction": round(extraction, 6),
            "unmet_demand": round(unmet_demand, 6),
            "critical_threshold": round(critical_threshold, 6),
            "below_critical_threshold": stock < critical_threshold,
        })

        stock = next_stock

    return rows


def summarize(rows: list[dict[str, object]], scenario: Scenario) -> dict[str, object]:
    stocks = [float(row["resource_stock"]) for row in rows]
    extraction = [float(row["extraction"]) for row in rows]
    regeneration = [float(row["regeneration"]) for row in rows]
    unmet_demand = [float(row["unmet_demand"]) for row in rows]

    threshold_times = [
        int(row["time"])
        for row in rows
        if bool(row["below_critical_threshold"])
    ]

    threshold_crossing_time: Optional[int]
    threshold_crossing_time = min(threshold_times) if threshold_times else None

    initial_stock = stocks[0]
    final_stock = stocks[-1]
    depletion_ratio = 1.0 - final_stock / max(initial_stock, 1e-9)

    return {
        "scenario": scenario.name,
        "initial_stock": round(initial_stock, 6),
        "final_stock": round(final_stock, 6),
        "minimum_stock": round(min(stocks), 6),
        "depletion_ratio": round(depletion_ratio, 6),
        "cumulative_extraction": round(sum(extraction), 6),
        "cumulative_regeneration": round(sum(regeneration), 6),
        "cumulative_unmet_demand": round(sum(unmet_demand), 6),
        "threshold_crossing_time": (
            threshold_crossing_time
            if threshold_crossing_time is not None
            else "not_crossed"
        ),
    }


def main() -> None:
    scenarios = [
        Scenario(name="baseline"),
        Scenario(name="high_demand", demand_growth=0.035),
        Scenario(
            name="conservation",
            conservation_sensitivity=0.85,
            max_conservation=0.55,
        ),
        Scenario(
            name="technology_rebound",
            demand_growth=0.030,
            extraction_efficiency=0.18,
            conservation_sensitivity=0.35,
            max_conservation=0.30,
        ),
        Scenario(
            name="regeneration_stress",
            regeneration_rate=0.045,
        ),
        Scenario(
            name="delayed_governance",
            demand_growth=0.025,
            conservation_sensitivity=0.20,
            max_conservation=0.20,
        ),
    ]

    all_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []
    parameter_rows: list[dict[str, object]] = []

    for scenario in scenarios:
        rows = simulate(scenario)
        all_rows.extend(rows)
        summary_rows.append(summarize(rows, scenario))

        parameter_rows.append({
            "scenario": scenario.name,
            "periods": scenario.periods,
            "carrying_capacity": scenario.carrying_capacity,
            "initial_stock": scenario.initial_stock,
            "regeneration_rate": scenario.regeneration_rate,
            "initial_demand": scenario.initial_demand,
            "demand_growth": scenario.demand_growth,
            "extraction_efficiency": scenario.extraction_efficiency,
            "conservation_sensitivity": scenario.conservation_sensitivity,
            "max_conservation": scenario.max_conservation,
            "reference_stock_fraction": scenario.reference_stock_fraction,
            "critical_threshold_fraction": scenario.critical_threshold_fraction,
        })

    validation_rows = [
        {
            "check": "scenario_runs_created",
            "passed": len(all_rows) > 0,
            "value": len(all_rows),
        },
        {
            "check": "resource_stock_nonnegative",
            "passed": all(float(row["resource_stock"]) >= 0 for row in all_rows),
            "value": "all_resource_stocks_checked",
        },
        {
            "check": "extraction_nonnegative",
            "passed": all(float(row["extraction"]) >= 0 for row in all_rows),
            "value": "all_extraction_values_checked",
        },
        {
            "check": "regeneration_nonnegative",
            "passed": all(float(row["regeneration"]) >= 0 for row in all_rows),
            "value": "all_regeneration_values_checked",
        },
        {
            "check": "summary_created",
            "passed": len(summary_rows) == len(scenarios),
            "value": len(summary_rows),
        },
    ]

    write_csv(TABLES / "python_resource_depletion_scenario_timeseries.csv", all_rows)
    write_csv(TABLES / "python_resource_depletion_scenario_summary.csv", summary_rows)
    write_csv(TABLES / "python_resource_depletion_scenario_parameters.csv", parameter_rows)
    write_csv(TABLES / "python_resource_depletion_validation_checks.csv", validation_rows)

    print("Stock-and-flow resource depletion workflow complete.")
    print(TABLES / "python_resource_depletion_scenario_summary.csv")


if __name__ == "__main__":
    main()

This workflow produces a reproducible depletion scenario set. It can be extended with stochastic shocks, sensitivity sweeps, spatial sub-stocks, stakeholder demand sectors, or calibration against real resource data.

Back to top ↑

GitHub Repository

Back to top ↑

Common Pitfalls

Stock-and-flow resource models are powerful because they clarify accumulation. They can also mislead if users treat a simplified model as a complete resource-management tool.

The central correction is disciplined interpretation. A stock-and-flow model is strongest when it reveals the logic of depletion without pretending to replace domain evidence, governance, or stakeholder judgment.

Back to top ↑

Conclusion

Stock-and-flow modeling makes resource depletion visible as an accumulation problem. A resource stock rises through regeneration and falls through extraction. When extraction persistently exceeds regeneration, depletion follows. When demand grows faster than renewal, a renewable resource can move toward scarcity. When scarcity response is delayed, the system can overshoot before corrective action becomes effective.

This case study shows why annual output is not enough. A system may look productive while its resource base is declining. It may continue satisfying demand until the stock becomes too depleted to support extraction or recovery. It may appear stable until a threshold is crossed. Stock-and-flow modeling helps reveal those hidden dynamics.

The strongest lesson is that sustainability depends on structure, feedback, and timing. Regeneration must be protected. Extraction must be bounded. Demand must be managed. Monitoring must track stock condition, not only flow output. Conservation must activate before crisis. Technology must be governed to avoid rebound. Policy must respond to early warning rather than late collapse.

This model is simple, but its logic is fundamental: if the stock is being drawn down faster than it is restored, the system is not sustainable, no matter how stable the annual flow appears.

Back to top ↑

Related Articles

• Systems Modeling
• Stocks, Flows, and Accumulation
• System Dynamics Modeling
• Scenario Modeling and Simulation
• Sensitivity Analysis in Systems Models
• Nonlinearity, Thresholds, and Regime Change
• Resilience and Adaptive Systems
• Critical Transitions and Tipping Points in Complex Systems
• Environmental Systems Modeling
• Integrated Assessment Models
• Case Study: Shock Propagation in Infrastructure Networks
• Case Study: Resilience Modeling Under Climate Stress

Further Reading

• MIT OpenCourseWare. Introduction to System Dynamics. Available at: https://ocw.mit.edu/courses/15-871-introduction-to-system-dynamics-fall-2013/.
• MIT Sloan System Dynamics. About Us. Available at: https://mitsloan.mit.edu/faculty/academic-groups/system-dynamics/about-us.
• System Dynamics Society. System Dynamics Society. Available at: https://systemdynamics.org/.
• Donella Meadows Project. Systems Thinking Resources. Available at: https://donellameadows.org/systems-thinking-resources/.
• Club of Rome. Data check on the World model that forecast global collapse. Available at: https://www.clubofrome.org/blog-post/herrington-world-model/.
• Turner, B.L., Menendez, H.M., Gates, R., Tedeschi, L.O. and Atzori, A.S. (2016) ‘System Dynamics Modeling for Agricultural and Natural Resource Management Issues: Review of Some Past Cases and Forecasting Future Roles’, Resources, 5(4), 40. Available at: https://www.mdpi.com/2079-9276/5/4/40.
• Baez, J., Li, X., Libkind, S., Osgood, N.D. and Patterson, E. (2022) ‘Compositional Modeling with Stock and Flow Diagrams’. Available at: https://arxiv.org/abs/2205.08373.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green.
• Meadows, D.H., Meadows, D.L., Randers, J. and Behrens, W.W. (1972) The Limits to Growth. New York: Universe Books.
• Meadows, D.L., Behrens, W.W., Meadows, D.H., Naill, R.F., Randers, J. and Zahn, E.K.O. (1974) Dynamics of Growth in a Finite World. Cambridge, MA: Wright-Allen Press.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Forrester, J.W. (1971) World Dynamics. Cambridge, MA: Wright-Allen Press.
• Clark, C.W. (1990) Mathematical Bioeconomics: The Optimal Management of Renewable Resources. 2nd edn. New York: Wiley.
• Gordon, H.S. (1954) ‘The Economic Theory of a Common-Property Resource: The Fishery’, Journal of Political Economy, 62(2), pp. 124–142.

Back to top ↑

References

• Baez, J., Li, X., Libkind, S., Osgood, N.D. and Patterson, E. (2022) ‘Compositional Modeling with Stock and Flow Diagrams’. Available at: https://arxiv.org/abs/2205.08373.
• Clark, C.W. (1990) Mathematical Bioeconomics: The Optimal Management of Renewable Resources. 2nd edn. New York: Wiley.
• Club of Rome. Data check on the World model that forecast global collapse. Available at: https://www.clubofrome.org/blog-post/herrington-world-model/.
• Donella Meadows Project. Systems Thinking Resources. Available at: https://donellameadows.org/systems-thinking-resources/.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Forrester, J.W. (1971) World Dynamics. Cambridge, MA: Wright-Allen Press.
• Gordon, H.S. (1954) ‘The Economic Theory of a Common-Property Resource: The Fishery’, Journal of Political Economy, 62(2), pp. 124–142.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green.
• Meadows, D.H., Meadows, D.L., Randers, J. and Behrens, W.W. (1972) The Limits to Growth. New York: Universe Books.
• Meadows, D.L., Behrens, W.W., Meadows, D.H., Naill, R.F., Randers, J. and Zahn, E.K.O. (1974) Dynamics of Growth in a Finite World. Cambridge, MA: Wright-Allen Press.
• MIT OpenCourseWare. Introduction to System Dynamics. Available at: https://ocw.mit.edu/courses/15-871-introduction-to-system-dynamics-fall-2013/.
• MIT Sloan System Dynamics. About Us. Available at: https://mitsloan.mit.edu/faculty/academic-groups/system-dynamics/about-us.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• System Dynamics Society. System Dynamics Society. Available at: https://systemdynamics.org/.
• Turner, B.L., Menendez, H.M., Gates, R., Tedeschi, L.O. and Atzori, A.S. (2016) ‘System Dynamics Modeling for Agricultural and Natural Resource Management Issues: Review of Some Past Cases and Forecasting Future Roles’, Resources, 5(4), 40. Available at: https://www.mdpi.com/2079-9276/5/4/40.

Back to top ↑