Upload 3 files

Sim_Engine (7).py

@@ -0,0 +1,207 @@
+def initialize_parcels(parcel_map, cluster_labels):
+    parcel_dict = {}
+    for i in range(parcel_map.shape[0]):
+        for j in range(parcel_map.shape[1]):
+            cluster_id = parcel_map[i, j]
+            land_type = cluster_labels.get(cluster_id, "Unknown")
+
+            parcel_dict[(i, j)] = {
+                "land_type": land_type,
+                "forage": None,
+                "health": 1.0,
+                "degraded": False,
+                "cattle_grazing": {
+                    "conservative": land_type == "Productive Grass",
+                    "moderate": land_type in ["Productive Grass", "Pasture/Desert"],
+                    "aggressive": land_type not in ["Water"]
+                },
+                "elk_grazing": {
+                    "default": land_type in ["Riparian Sensitive Zone", "Productive Grass"]
+                }
+            }
+    return parcel_dict
+
+def get_land_forage_rates():
+    return {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+
+
+def assign_initial_forage(parcel_dict, land_forage_rates):
+    for parcel in parcel_dict.values():
+        rate = land_forage_rates.get(parcel["land_type"], 0.0)
+        parcel["forage"] = rate * 100  # initial AUMs
+
+import numpy as np
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import Counter
+from matplotlib.colors import ListedColormap
+import matplotlib.patches as mpatches
+
+def simulate_period(parcel_dict, grazing_strategy="moderate", cattle_stocking_rate=100000, elk_pressure=3000):
+    print(f"\n🟢 Running LP-based simulation using grazing strategy: **{grazing_strategy.upper()}**")
+
+    import numpy as np
+    from scipy.optimize import linprog
+
+    keys = list(parcel_dict.keys())
+    n_rows = max(i for i, _ in keys) + 1
+    n_cols = max(j for _, j in keys) + 1
+    num_cells = n_rows * n_cols
+
+    # Step 1: Regrowth
+    land_growth_rates = {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+    for parcel in parcel_dict.values():
+        base_growth = land_growth_rates.get(parcel["land_type"], 0.0)
+        weather = np.random.normal(1.0, 0.15)
+        regrowth = base_growth * weather * 1
+        regrowth *= parcel["health"]
+        parcel["forage"] = min(parcel["forage"] + regrowth, 100)
+
+    # Step 2: Subtract uniform elk grazing from all parcels
+    elk_grazing_per_parcel = elk_pressure / num_cells
+    for parcel in parcel_dict.values():
+        parcel["forage"] -= elk_grazing_per_parcel
+        parcel["forage"] = max(parcel["forage"], 0.0)
+
+    # Step 3: LP for cattle
+    cost = []
+    bounds = []
+    eligible_keys = []
+    for i in range(n_rows):
+        for j in range(n_cols):
+            p = parcel_dict[(i, j)]
+            if not p["cattle_grazing"].get(grazing_strategy, False):
+                cost.append(0)
+                bounds.append((0, 0))
+                continue
+            if grazing_strategy in {"conservative", "moderate"} and p["land_type"] == "Riparian Sensitive Zone":
+                cost.append(0)
+                bounds.append((0, 0))
+                continue
+            cost.append((i + j) * 0.02)
+            bounds.append((0, p["forage"]))
+            eligible_keys.append((i, j))
+
+    A_eq = [1.0 if b[1] > 0 else 0.0 for b in bounds]
+    b_eq = [cattle_stocking_rate]
+
+    result = linprog(c=cost, A_eq=[A_eq], b_eq=b_eq, bounds=bounds, method="highs")
+    if not result.success:
+        raise RuntimeError("Grazing LP failed: " + result.message)
+
+    grazing_values = result.x
+
+    # Step 4: Apply grazing and your specified health rule
+    for idx, ((i, j), x) in enumerate(zip(parcel_dict.keys(), grazing_values)):
+        parcel = parcel_dict[(i, j)]
+        parcel["forage"] -= x
+
+        # ✅ Your health rule (fully time-dynamic)
+        if parcel["forage"] <= 0:
+            parcel["health"] = max(parcel["health"] - 0.25, 0.0)
+        elif parcel["forage"] < 20:
+            parcel["health"] = max(parcel["health"] - 0.1, 0.0)
+        else:
+            parcel["health"] = min(parcel["health"] + 0.02, 1.0)
+
+def simulate_periodold(parcel_dict, grazing_strategy="moderate", cattle_stocking_rate=5000, elk_pressure=3000):
+    print(f"\n🟢 Running simulation using cattle grazing strategy: **{grazing_strategy.upper()}**")
+
+    land_growth_rates = {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+
+    # 1. Simulate forage regrowth for 8 months
+    for parcel in parcel_dict.values():
+        base_growth = land_growth_rates.get(parcel["land_type"], 0.0)
+        weather = np.random.normal(1.0, 0.15)
+        regrowth = base_growth * weather * 8  # ← 8 months, as you said
+        regrowth *= parcel["health"]  # degrade means slower regrowth
+        parcel["forage"] = min(parcel["forage"] + regrowth, 100)
+
+    # 2. Count eligible parcels
+    total_grazed_parcels = sum(
+        1 for parcel in parcel_dict.values() if parcel["cattle_grazing"].get(grazing_strategy, False)
+    )
+    if total_grazed_parcels == 0:
+        print("⚠️ No parcels match the selected grazing strategy.")
+        return
+
+    cattle_grazing_per_parcel = cattle_stocking_rate / total_grazed_parcels
+    elk_grazing_per_parcel = elk_pressure / len(parcel_dict)
+
+    # 3. Simulate grazing and degradation
+    for parcel in parcel_dict.values():
+        if not parcel["cattle_grazing"].get(grazing_strategy, False):
+            continue
+
+        total_grazing = cattle_grazing_per_parcel + elk_grazing_per_parcel
+
+        if total_grazing > parcel["forage"]:
+            parcel["degraded"] = True
+            parcel["health"] = max(parcel["health"] - 0.1, 0.0)
+        else:
+            parcel["health"] = min(parcel["health"] + 0.02, 1.0)
+
+        parcel["forage"] = max(parcel["forage"] - total_grazing, 0)
+
+def get_forage_map(parcel_dict, n_rows, n_cols):
+    return np.array([[parcel_dict[(i, j)]["forage"] for j in range(n_cols)] for i in range(n_rows)])
+
+def get_health_map(parcel_dict, n_rows, n_cols):
+    """
+    Returns a 2D numpy array representing the health of each parcel.
+    """
+    return np.array([[parcel_dict[(i, j)]["health"] for j in range(n_cols)] for i in range(n_rows)])
+
+
+def plot_health_map(health_map, title="Parcel Health Levels", save_path=None):
+    """
+    Plots a heatmap of the parcel health values.
+    """
+    import matplotlib.pyplot as plt
+
+    plt.figure(figsize=(8, 6))
+    plt.imshow(health_map, cmap='RdYlGn', origin='upper', vmin=0, vmax=1)
+    plt.colorbar(label="Health Index (0–1)")
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    if save_path:
+        plt.savefig(save_path)
+    plt.show()
+
+
+
+def plot_forage_map(forage_map, title="Parcel Forage Levels"):
+    plt.figure(figsize=(8, 6))
+    plt.imshow(forage_map, cmap='YlGn', origin='upper')
+    plt.colorbar(label="Forage AUMs")
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+def run_full_simulation(parcel_map, cluster_labels, n_rows, n_cols, strategy="moderate"):
+    parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+    land_forage_rates = get_land_forage_rates()
+    assign_initial_forage(parcel_dict, land_forage_rates)
+    simulate_period(parcel_dict, grazing_strategy=strategy)
+    return parcel_dict
+

app (21).py

@@ -0,0 +1,122 @@
+import os
+import gradio as gr
+import numpy as np
+from openai import OpenAI
+from Sim_Setup_Fcns import (
+    load_and_crop_image, cluster_image, build_parcel_map,
+    get_cluster_labels, get_land_colors, plot_parcel_map_to_file
+)
+from Sim_Engine import run_full_simulation
+from feedback_fcns import (
+    summarize_initial_conditions, plot_forage_map_to_file,
+    elk_feedback, usfs_feedback, simulate_and_summarize, full_response
+)
+
+from zone_utils import (
+    identify_zones, plot_labeled_zones,
+    assign_zone_labels, save_zone_info_to_excel,override_zone_id_and_label
+)
+
+# === Setup on Launch ===
+img = load_and_crop_image("Carson_map.png")
+clustered_img = cluster_image(img)
+parcel_map, n_rows, n_cols = build_parcel_map(clustered_img)
+cluster_labels = get_cluster_labels()
+land_colors = get_land_colors()
+plot_parcel_map_to_file(parcel_map, cluster_labels, land_colors, save_path="clustered_map.png")
+
+# === Zoning ===
+
+# 1. Identify contiguous zones
+zone_map, zone_to_cluster = identify_zones(parcel_map, connectivity="queen")
+
+# 2. Assign human-readable labels (before override)
+zone_labels = assign_zone_labels(zone_to_cluster)
+# === Manual override for mislabeled riparian zone ===
+# First, update the zone label once
+for zid, lbl in zone_labels.items():
+    if lbl == "A" and zone_to_cluster[zid] == 1:
+        zone_labels[zid] = "Riparian A1"
+    if lbl == "M" and zone_to_cluster[zid] == 1:
+         zone_labels[zid] = "Riparian A2"
+# Then update all matching parcels
+for i in range(n_rows):
+    for j in range(n_cols):
+        zone_id = zone_map[i, j]
+        if zone_labels.get(zone_id) == "Riparian A1":
+            parcel_map[i, j] = 2
+        if zone_labels.get(zone_id) == "Riparian A2":
+            parcel_map[i, j] = 2
+
+#       
+
+
+# ⬇️ Add this block right after the override
+zone_to_cluster = {}
+for zone_id in np.unique(zone_map):
+    indices = np.argwhere(zone_map == zone_id)
+    if len(indices) > 0:
+        i, j = indices[0]
+        zone_to_cluster[zone_id] = parcel_map[i, j]
+
+# 6. Plot labeled zones after override and mapping
+plot_labeled_zones(zone_map, zone_labels, zone_to_cluster, save_path="zones_labeled.png")
+
+# 5. Define cluster-to-class mapping (should stay after override)
+cluster_to_class = {
+    0: "desert",
+    1: "pasture",
+    2: "riparain",
+    3: "sensitive riparian",
+    4: "wetland",
+    5: "water"
+}
+
+# 7. Save zone info to Excel
+zone_excel_path = "zone_info.xlsx"
+save_zone_info_to_excel(
+    parcel_map, zone_map, zone_labels, zone_to_cluster, cluster_to_class,
+    save_path=zone_excel_path
+)
+
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+# === Gradio App ===
+with gr.Blocks() as demo:
+    gr.Markdown("# AGEC 3052 — Grazing Strategy Simulation")
+    gr.Image(value="clustered_map.png", label="Initial 25×25 Parcel Layout")
+    gr.Image(value="zones_labeled.png", label="Labeled Pasture & Riparian Zones")
+    # ✅ Downloadable Excel
+    gr.File(value=zone_excel_path, label="Download Zone Info (Excel)")
+    
+    plan = gr.Radio(["Conservative", "Normal", "Aggressive"], label="Grazing Plan")
+    essay = gr.Textbox(lines=8, label="Your Essay Justifying the Plan")
+
+    elk_output = gr.Textbox(label="Elk Stakeholder Feedback")
+    usfs_output = gr.Textbox(label="USFS Feedback")
+    sim_output = gr.Textbox(label="Simulation Results", lines=2)
+    sim_image = gr.Image(label="Forage Map After Simulation", type="filepath")
+    health_image = gr.Image(label="Health Map After Simulation", type="filepath")
+
+    round_counter = gr.State(value=1)
+    history = gr.State(value=[summarize_initial_conditions(n_rows, n_cols)])
+
+    def submit_handler(plan_choice, essay_text, history_val):
+        return full_response(plan_choice, essay_text, history_val[-1])
+
+    def sim_handler(plan_choice, round_val, history_val):
+        summary, map_path, health_path, new_round = simulate_and_summarize(
+            plan_choice, round_val, parcel_map, cluster_labels, n_rows, n_cols,
+            run_full_simulation, history_val
+        )
+        history_val.append(summary)
+        return summary, map_path, health_path, new_round, history_val
+
+    submit_btn = gr.Button("Submit Grazing Plan")
+    sim_btn = gr.Button("Run Simulation")
+
+    submit_btn.click(fn=submit_handler, inputs=[plan, essay, history], outputs=[elk_output, usfs_output])
+    sim_btn.click(fn=sim_handler, inputs=[plan, round_counter, history], outputs=[sim_output, sim_image, health_image, round_counter, history])
+
+demo.launch()

feedback_fcns (7).py

@@ -0,0 +1,167 @@
+import os
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+from openai import OpenAI
+from Sim_Engine import simulate_period
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+def summarize_initial_conditions(n_rows, n_cols):
+    num_parcels = n_rows * n_cols
+    avg_forage = round(random.uniform(6.5, 8.0), 1)
+    degraded_pct = round(random.uniform(0.0, 2.0), 1)
+    riparian_health = random.choice(["excellent", "moderate", "fragile"])
+    elk_corridor_status = random.choice([
+        "completely intact and lightly used",
+        "intact but under slight pressure from cattle movement",
+        "showing signs of fragmentation near key crossings"
+    ])
+    rainfall_outlook = random.choice(["normal", "below average", "above average"])
+
+    return (
+        f"There are {num_parcels} parcels in total. Grazing has not yet occurred.\n"
+        f"Average forage availability is {avg_forage} AUMs per parcel, with about {degraded_pct}% of land already degraded due to prior conditions.\n"
+        f"Riparian zone condition is {riparian_health}, and the elk movement corridor is {elk_corridor_status}.\n"
+        f"The seasonal rainfall outlook is {rainfall_outlook}."
+    )
+
+def plot_forage_map_to_file(parcel_dict, n_rows, n_cols, title="Forage Map", save_path="forage_map.png"):
+    forage_map = np.array([
+        [parcel_dict[(i, j)]["forage"] for j in range(n_cols)]
+        for i in range(n_rows)
+    ])
+    fig, ax = plt.subplots(figsize=(8, 6))
+    cax = ax.imshow(forage_map, cmap='YlGn', origin='upper')
+    fig.colorbar(cax, label="Forage AUMs")
+    ax.set_title(title)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+def elk_feedback(plan_choice, current_summary):
+    prompt = f"""
+You represent a coalition of elk-related interests: conservationists, hunting advocates, and the hospitality/lodging industry.
+A student has selected the **'{plan_choice}'** cattle grazing strategy. Below are the current ecological conditions:
+-----
+{current_summary}
+-----
+Please do the following:
+- Explicitly choose **one elk management strategy** from the list:
+  - **Preserve**: strict elk protections, no hunting, unrestricted movement
+  - **Cooperate**: shared use corridor, some riparian restrictions, sustainable elk population
+  - **Exploit**: prioritize hunting/tourism, tolerate reduced elk numbers and access
+- Reflect each group's view briefly, but unify the final position.
+- Justify your strategy choice based on the above ecological indicators.
+"""
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.8
+    )
+    return response.choices[0].message.content
+
+def usfs_feedback(plan_choice, student_essay, current_summary):
+    # Extract the AUM line from the summary
+    aum_line = ""
+    for line in current_summary.split("\n"):
+        if "Average forage availability" in line:
+            aum_line = line.strip()
+            break
+
+    prompt = f"""
+You are a USFS land management agent evaluating a student’s cattle grazing proposal.
+
+The student selected the **'{plan_choice}'** strategy and submitted this justification:
+-----
+{student_essay}
+-----
+
+Here are the current rangeland conditions:
+-----
+{current_summary}
+-----
+
+🚨 **Must Include Block**:
+You must include this sentence exactly in your response:
+→ "{aum_line}"
+
+Then provide your evaluation:
+- Comment on forage, degradation, riparian and corridor health
+- State whether the plan is ecologically sound
+- Suggest improvements if needed
+- Keep the tone professional, clear, and grounded in the data
+"""
+
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7
+    )
+    return response.choices[0].message.content
+
+def simulate_and_summarizeold(plan_choice, round_counter, parcel_dict, parcel_map, cluster_labels, n_rows, n_cols, elk_pressure):
+    # Interpret strategy
+    strategy_map = {
+        "conservative": "conservative",
+        "normal": "moderate",
+        "aggressive": "aggressive"
+    }
+    strategy = strategy_map.get(plan_choice.lower(), "moderate")
+
+    # ✅ Reuse incoming parcel_dict — do not reset
+    simulate_period(parcel_dict, grazing_strategy=strategy, elk_pressure=elk_pressure)
+
+    # Extract summary
+    forage_vals = [p["forage"] for p in parcel_dict.values()]
+    avg_forage = sum(forage_vals) / len(forage_vals)
+    degraded_pct = 100 * sum(p["health"] < 0.5 for p in parcel_dict.values()) / len(parcel_dict)
+
+    summary = (
+        f"After Round {round_counter} with the '{plan_choice}' plan:\n"
+        f"Avg forage: {avg_forage:.1f} AUMs, Parcels with low health (<0.5): {degraded_pct:.1f}%"
+    )
+
+    # Generate map visuals
+    from Sim_Engine import get_forage_map, get_health_map, plot_forage_map, plot_health_map
+    forage_map = get_forage_map(parcel_dict, n_rows, n_cols)
+    health_map = get_health_map(parcel_dict, n_rows, n_cols)
+    plot_forage_map(forage_map, title=f"Forage Map (Round {round_counter})", save_path="forage_map.png")
+    plot_health_map(health_map, title=f"Health Map (Round {round_counter})", save_path="health_map.png")
+
+    return summary, "forage_map.png", "health_map.png", round_counter + 1, parcel_dict
+
+def simulate_and_summarize(plan_choice, round_counter, parcel_map, cluster_labels, n_rows, n_cols, run_full_simulation, history):
+
+    strategy_map = {
+        "conservative": "conservative",
+        "normal": "moderate",
+        "aggressive": "aggressive"
+    }
+    strategy = strategy_map.get(plan_choice.lower())
+    parcel_dict = run_full_simulation(parcel_map, cluster_labels, n_rows, n_cols, strategy=strategy)
+
+    plot_forage_map_to_file(parcel_dict, n_rows, n_cols, title=f"Round {round_counter} Forage Map")
+
+    # ✅ ADD THIS BLOCK
+    from Sim_Engine import get_health_map, plot_health_map
+    health_map = get_health_map(parcel_dict, n_rows, n_cols)
+    plot_health_map(health_map, title=f"Round {round_counter} Health Map", save_path="health_map.png")
+
+    
+    forage_vals = [p["forage"] for p in parcel_dict.values()]
+    avg_forage = sum(forage_vals) / len(forage_vals)
+    degraded_pct = 100 * sum(p["degraded"] for p in parcel_dict.values()) / len(parcel_dict)
+
+    summary = (
+        f"After Round {round_counter} with the '{plan_choice}' plan:\n"
+        f"Avg forage: {avg_forage:.1f} AUMs, Degraded parcels: {degraded_pct:.1f}%"
+    )
+    return summary, "forage_map.png", "health_map.png", round_counter + 1
+
+
+def full_response(plan_choice, essay_text, current_summary):
+    elk_resp = elk_feedback(plan_choice, current_summary)
+    usfs_resp = usfs_feedback(plan_choice, essay_text, current_summary)
+    return elk_resp, usfs_resp