Upload folder using huggingface_hub

gridops/server/environment.py

@@ -107,6 +107,10 @@ class GridOpsEnvironment(Environment):
             )
 
         h = self._micro.hour
+        # Check if grid is available this hour (outage = islanding mode)
+        outage_hours = self._cfg.grid_outage_hours or []
+        grid_up = h not in outage_hours
+
         result = physics.step(
             self._micro,
             battery_dispatch_norm=action.battery_dispatch,
@@ -116,6 +120,7 @@ class GridOpsEnvironment(Environment):
             demand_kw=float(self._demand[h]),
             grid_price=float(self._price[h]),
             diesel_fuel_cap=self._cfg.diesel_fuel_capacity * DIESEL_TANK_KWH,
+            grid_available=grid_up,
         )
 
         self._last_flows = result.flows
@@ -137,7 +142,8 @@ class GridOpsEnvironment(Environment):
 
         if result.done:
             self._grade = grade_episode(
-                self._micro, self._demand, self._solar, self._price
+                self._micro, self._demand, self._solar, self._price,
+                grid_outage_hours=self._cfg.grid_outage_hours,
             )
 
         obs = self._make_observation(

gridops/server/static/index.html

@@ -577,7 +577,7 @@
       <div class="control-group">
         <label>&#127968; Ask residents to cut usage <span class="val" id="shedVal">none</span></label>
         <input type="range" id="shedSlider" min="0" max="100" value="0" step="1">
-        <div style="font-size:9px;color:var(--yellow)">50% of shed demand rebounds next hour!</div>
+        <div style="font-size:9px;color:var(--yellow)">100% rebounds next hour! Rs 40/kWh penalty.</div>
       </div>
     </div>
 

gridops/simulation/physics.py

@@ -30,7 +30,7 @@ DIESEL_MAX_KW = 100.0
 DIESEL_COST_PER_KWH = 25.0
 DIESEL_STARTUP_COST = 100.0        # Rs, one-time when turning on from off
 DEMAND_SHED_MAX_FRAC = 0.20
-SHED_REBOUND_FRAC = 0.50           # 50% of shed energy rebounds next hour
+SHED_REBOUND_FRAC = 1.00           # 100% of shed energy rebounds next hour (deferred, not destroyed)
 DIESEL_TANK_KWH = 2400.0           # total fuel capacity
 VOLL = 150.0                       # Value of Lost Load (Rs/kWh)
 DT = 1.0                           # 1 hour per step
@@ -102,6 +102,7 @@ def step(
     demand_kw: float,
     grid_price: float,
     diesel_fuel_cap: float = DIESEL_TANK_KWH,
+    grid_available: bool = True,
 ) -> StepResult:
     """
     Advance the microgrid by one hour.
@@ -119,7 +120,7 @@ def step(
     shed_frac = float(np.clip(shed_norm, 0, 1)) * DEMAND_SHED_MAX_FRAC
 
     # ── Demand (with shedding rebound from last step) ────────────────
-    actual_demand = demand_kw + state.shed_rebound_kwh
+    actual_demand = demand_kw + state.shed_rebound_kwh / DT  # rebound is kWh, convert to kW
     effective_demand = actual_demand * (1.0 - shed_frac)
     shed_kwh = actual_demand * shed_frac * DT
     state.shed_rebound_kwh = shed_kwh * SHED_REBOUND_FRAC  # 50% rebounds next hour
@@ -152,16 +153,17 @@ def step(
     # ── Grid as slack variable ───────────────────────────────────────
     # residual = what the community still needs after solar + battery + diesel
     # positive → grid must import; negative → surplus exported
+    grid_cap = GRID_MAX_KW if grid_available else 0.0
     residual = effective_demand - solar_kw - delivered_kw - diesel_kw
-    grid_kw = float(np.clip(residual, -GRID_MAX_KW, GRID_MAX_KW))
+    grid_kw = float(np.clip(residual, -grid_cap, grid_cap))
 
     # ── Blackout / curtailment detection ─────────────────────────────
     blackout_kwh = 0.0
     curtailed_kw = 0.0
-    if residual > GRID_MAX_KW:
-        blackout_kwh = (residual - GRID_MAX_KW) * DT
-    elif residual < -GRID_MAX_KW:
-        curtailed_kw = abs(residual) - GRID_MAX_KW  # excess that can't be exported
+    if residual > grid_cap:
+        blackout_kwh = (residual - grid_cap) * DT
+    elif residual < -grid_cap:
+        curtailed_kw = abs(residual) - grid_cap  # excess that can't be exported
 
     # ── Build flow snapshot ──────────────────────────────────────────
     grid_import = max(0.0, grid_kw)
@@ -208,8 +210,9 @@ def step(
     # VoLL penalty (replaces hard reliability gate)
     step_cost += VOLL * blackout_kwh
 
-    # Shedding penalty (small comfort cost — Rs 5/kWh shed)
-    step_cost += 5.0 * shed_kwh
+    # Shedding penalty (comfort + political cost — Rs 40/kWh shed)
+    # More expensive than diesel (Rs 25), so only used as true emergency
+    step_cost += 40.0 * shed_kwh
 
     # ── Fuel accounting ──────────────────────────────────────────────
     state.diesel_fuel_kwh -= diesel_kw * DT
@@ -235,7 +238,7 @@ def step(
 
     # ── Narration ────────────────────────────────────────────────────
     narration = _narrate(state, solar_kw, actual_demand, grid_price, blackout_kwh,
-                         diesel_kw, shed_frac, grid_kw, delivered_kw)
+                         diesel_kw, shed_frac, grid_kw, delivered_kw, grid_available)
 
     return StepResult(state=state, reward=reward, done=done, narration=narration, flows=flows)
 
@@ -250,6 +253,7 @@ def _narrate(
     shed: float,
     grid_kw: float,
     battery_kw: float,
+    grid_available: bool = True,
 ) -> str:
     """Generate a short human-readable situation summary."""
     START_HOUR = 6
@@ -260,6 +264,9 @@ def _narrate(
 
     parts = [f"Day {day}, {hour_of_day:02d}:00."]
 
+    if not grid_available:
+        parts.append("GRID OUTAGE — islanding mode! No grid import/export.")
+
     if blackout > 0:
         parts.append(f"BLACKOUT: {blackout:.0f} kWh unmet!")
     elif demand > 200:

gridops/simulation/scenarios.py

@@ -27,6 +27,7 @@ class ScenarioConfig:
     cloud_hours: list[int] | None = None  # hours with intermittent clouds
     diesel_fuel_capacity: float = 1.0   # 1.0 = full tank (800 kWh worth)
     forecast_noise: float = 0.15        # ±15 % Gaussian noise on forecasts
+    grid_outage_hours: list[int] | None = None  # hours where grid cap drops to 0 (islanding)
 
 
 # ── Demand ───────────────────────────────────────────────────────────────

gridops/tasks/definitions.py

@@ -1,9 +1,9 @@
 """
 Three task configurations with escalating difficulty.
 
-Task 1: Normal Summer (easy)
-Task 2: Heatwave + Clouds (medium)
-Task 3: Extreme Crisis (hard)
+Task 1: Normal Summer (easy) — basic arbitrage
+Task 2: Heatwave + Price Spike (medium) — forces forecasting / temporal planning
+Task 3: Extreme Crisis + Grid Outage (hard) — forces islanding / constraint management
 """
 
 from gridops.simulation.scenarios import ScenarioConfig
@@ -19,21 +19,30 @@ TASK_1_NORMAL = ScenarioConfig(
     cloud_hours=None,
     diesel_fuel_capacity=1.0,
     forecast_noise=0.15,
+    grid_outage_hours=None,
 )
 
+# Task 2: Heatwave + severe evening price spikes on Day 2-3.
+# Mid-day prices dip (solar glut), then spike to Rs 18-20 at evening.
+# A greedy agent discharges battery mid-day; an RL agent reads the
+# 4-hour forecast and HOLDS charge for the evening spike.
 TASK_2_HEATWAVE = ScenarioConfig(
     demand_multiplier=1.3,
     solar_multiplier=1.0,
-    price_floor=5.0,
+    price_floor=3.0,
     price_ceiling=15.0,
-    price_spike_hour=44,         # Day 2, 20:00 (hour 44)
-    price_spike_value=18.0,
+    price_spike_hour=36,         # Day 2, ~18:00 (step 36 = hour 12 of day 2)
+    price_spike_value=20.0,      # severe spike — hold battery for this
     heatwave_start_hour=24,      # Day 2 start
-    cloud_hours=[30, 31, 36, 37, 54, 55],  # intermittent Day 2-3
+    cloud_hours=[30, 31, 36, 37, 54, 55],
     diesel_fuel_capacity=1.0,
     forecast_noise=0.15,
+    grid_outage_hours=None,
 )
 
+# Task 3: Full crisis + 6-hour grid outage on Day 2 evening.
+# Grid cap drops to 0 kW during outage — agent must survive on
+# battery + diesel + shedding alone. Tests true islanding capability.
 TASK_3_CRISIS = ScenarioConfig(
     demand_multiplier=1.5,
     solar_multiplier=0.7,
@@ -41,10 +50,11 @@ TASK_3_CRISIS = ScenarioConfig(
     price_ceiling=20.0,
     price_spike_hour=44,
     price_spike_value=20.0,
-    heatwave_start_hour=0,       # heatwave from the start
+    heatwave_start_hour=0,
     cloud_hours=list(range(8, 16)) + list(range(32, 40)) + list(range(56, 64)),
     diesel_fuel_capacity=0.33,   # 800 kWh ≈ 8 hrs at 100 kW
     forecast_noise=0.15,
+    grid_outage_hours=list(range(30, 36)),  # 6-hour outage: Day 2, ~12:00-18:00
 )
 
 TASKS = {

gridops/tasks/graders.py

@@ -28,26 +28,27 @@ def compute_dumb_baseline_cost(
     demand_curve: np.ndarray,
     solar_curve: np.ndarray,
     price_curve: np.ndarray,
+    grid_outage_hours: list[int] | None = None,
 ) -> float:
     """Cost of a dumb baseline: import max grid, no battery/diesel/shedding.
 
     Where demand > grid + solar, apply VoLL for the blackout.
-    This is a realistic "no-intelligence" baseline.
+    During grid outages, all non-solar demand is blackout.
     """
+    outages = set(grid_outage_hours or [])
     total_cost = 0.0
     for h in range(len(demand_curve)):
         demand = demand_curve[h]
         solar = solar_curve[h]
         price = price_curve[h]
+        grid_cap = 0.0 if h in outages else GRID_MAX_KW
 
-        # Grid covers what it can (up to 200 kW)
         needed_from_grid = max(0.0, demand - solar)
-        grid_import = min(needed_from_grid, GRID_MAX_KW)
-        total_cost += price * grid_import  # grid cost
+        grid_import = min(needed_from_grid, grid_cap)
+        total_cost += price * grid_import
 
-        # Any excess demand is a blackout
-        unmet = max(0.0, needed_from_grid - GRID_MAX_KW)
-        total_cost += VOLL * unmet  # VoLL penalty
+        unmet = max(0.0, needed_from_grid - grid_cap)
+        total_cost += VOLL * unmet
 
     return float(total_cost)
 
@@ -57,6 +58,7 @@ def grade_episode(
     demand_curve: np.ndarray,
     solar_curve: np.ndarray,
     price_curve: np.ndarray,
+    grid_outage_hours: list[int] | None = None,
 ) -> dict:
     """
     Grade a completed episode. Returns dict with score 0.0-1.0.
@@ -71,7 +73,7 @@ def grade_episode(
     reliability = float(np.clip(reliability, 0, 1))
 
     # Cost efficiency: how much better than dumb baseline
-    baseline_cost = compute_dumb_baseline_cost(demand_curve, solar_curve, price_curve)
+    baseline_cost = compute_dumb_baseline_cost(demand_curve, solar_curve, price_curve, grid_outage_hours)
     actual_cost = state.cumulative_cost
     if baseline_cost > 0:
         cost_efficiency = 1.0 - (actual_cost / baseline_cost)

openenv.yaml

@@ -36,4 +36,4 @@ metadata:
   observation_space: "12 fields: hour, demand, solar, battery_soc, price, fuel, 3×4h forecasts, cumulative metrics"
   episode_length: 72
   step_duration: "1 hour"
-  grading: "Reliability-gated composite: 60% cost savings + 20% reliability + 20% green score"
+  grading: "Composite: 50% cost efficiency + 25% reliability + 25% green score. VoLL Rs 150/kWh blackout penalty."