@@ -7,28 +7,32 @@ import (
 
 // SystemConfig holds the inverter system configuration
 type SystemConfig struct {
-	BatteryCapacity        float64 // kWh
-	BatteryMaxCharge       float64 // kW
-	BatteryMaxDischarge    float64 // kW
-	BatteryMinSOC          float64 // percentage (0-1)
-	BatteryMaxSOC          float64 // percentage (0-1)
-	BatteryEfficiency      float64 // round-trip efficiency (0-1)
-	BatteryDegradationCost float64 // $/kWh cycled
-	MaxGridImport          float64 // kW
-	MaxGridExport          float64 // kW
+	BatteryCapacity             float64 // kWh
+	BatteryMaxCharge            float64 // kW
+	BatteryMaxDischarge         float64 // kW
+	BatteryMinSOC               float64 // percentage (0-1)
+	BatteryMaxSOC               float64 // percentage (0-1)
+	BatteryEfficiency           float64 // round-trip efficiency (0-1)
+	BatteryDegradationCost      float64 // $/kWh cycled
+	MaxGridImport               float64 // kW
+	MaxGridExport               float64 // kW
+	BatteryPreHeatPower         float64 // kW - power consumption of battery preheating when active
+	BatteryPreHeatTempThreshold float64 // °C - temperature threshold below which battery preheating activates
+	BatteryThermalTimeConstant  float64 // fraction per time slot - rate at which battery temperature approaches air temperature (0-1)
 }
 
 // TimeSlot represents one time period of operation (typically 15 minutes, configurable via check_price_interval)
 type TimeSlot struct {
-	Hour          int
-	Timestamp     int64   // Unix timestamp when this time slot begins
-	ImportPrice   float64 // $/kWh
-	ExportPrice   float64 // $/kWh
-	SolarForecast float64 // kW average for the time period
-	LoadForecast  float64 // kW average for the time period
-	CloudCoverage float64 // % cloud coverage (0-100)
-	WeatherSymbol string  // weather condition symbol
-	AirTemperature float64 // °C air temperature
+	Hour               int
+	Timestamp          int64   // Unix timestamp when this time slot begins
+	ImportPrice        float64 // $/kWh
+	ExportPrice        float64 // $/kWh
+	SolarForecast      float64 // kW average for the time period
+	LoadForecast       float64 // kW average for the time period
+	CloudCoverage      float64 // % cloud coverage (0-100)
+	WeatherSymbol      string  // weather condition symbol
+	AirTemperature     float64 // °C air temperature
+	BatteryAvgCellTemp float64 // °C average cell temperature
 }
 
 // ControlDecision represents the optimal control for one time slot (typically 15 minutes, configurable via check_price_interval)
@@ -43,6 +47,7 @@ type ControlDecision struct {
 	GridExport            float64 // kW (positive = exporting)
 	BatterySOC            float64 // percentage (0-1)
 	Profit                float64 // $ for this time period
+	BatteryPreHeatActive  bool    // true if battery preheating is active during this time slot
 	// Forecast data used for this decision
 	ImportPrice        float64 // $/kWh
 	ExportPrice        float64 // $/kWh
@@ -171,6 +176,7 @@ func (mpc *Controller) optimizeWithForecast(forecast []TimeSlot, includeSolar bo
 					dp[t+1][newSOCIdx].decision.CloudCoverage = slot.CloudCoverage
 					dp[t+1][newSOCIdx].decision.WeatherSymbol = slot.WeatherSymbol
 					dp[t+1][newSOCIdx].decision.AirTemperature = slot.AirTemperature
+					dp[t+1][newSOCIdx].decision.BatteryAvgCellTemp = slot.BatteryAvgCellTemp
 					dp[t+1][newSOCIdx].prevSOC = socIdx
 				}
 			}
@@ -203,6 +209,14 @@ func (mpc *Controller) optimizeWithForecast(forecast []TimeSlot, includeSolar bo
 func (mpc *Controller) generateFeasibleDecisions(currentSOC float64, slot TimeSlot) []ControlDecision {
 	decisions := []ControlDecision{}
 
+	// Determine if battery preheating would be needed based on battery temperature
+	// Battery preheating is only active when actually charging the battery
+	needsPreHeat := mpc.Config.BatteryPreHeatPower > 0 && slot.BatteryAvgCellTemp < mpc.Config.BatteryPreHeatTempThreshold
+	preHeatPower := 0.0
+	if needsPreHeat {
+		preHeatPower = mpc.Config.BatteryPreHeatPower
+	}
+
 	// Always include idle option
 	batteryActions := []struct {
 		charge    float64
@@ -242,16 +256,28 @@ func (mpc *Controller) generateFeasibleDecisions(currentSOC float64, slot TimeSl
 
 	// For each battery action, calculate power balance
 	for _, action := range batteryActions {
+		// Battery preheating is only active when we're actually charging and temp is below threshold
+		preHeatActive := needsPreHeat && action.charge > 0
+		
 		dec := ControlDecision{
-			Hour:             slot.Hour,
-			Timestamp:        slot.Timestamp,
-			BatteryCharge:    action.charge,
-			BatteryDischarge: action.discharge,
+			Hour:                 slot.Hour,
+			Timestamp:            slot.Timestamp,
+			BatteryCharge:        action.charge,
+			BatteryDischarge:     action.discharge,
+			BatteryPreHeatActive: preHeatActive,
 		}
 
-		// Power balance: Solar + GridImport + BatteryDischarge = Load + GridExport + BatteryCharge
+		// Power balance: Solar + GridImport + BatteryDischarge = Load + GridExport + BatteryCharge + BatteryPreHeat
+		// When battery preheating is active (battery is charging at low temp), it consumes extra power from the grid
 		netSolar := slot.SolarForecast
-		netLoad := slot.LoadForecast + action.charge/mpc.Config.BatteryEfficiency
+		extraLoad := 0.0
+		
+		// Battery preheating only consumes power when battery is charging
+		if preHeatActive {
+			extraLoad = preHeatPower
+		}
+		
+		netLoad := slot.LoadForecast + action.charge/mpc.Config.BatteryEfficiency + extraLoad
 		netSupply := netSolar + action.discharge*mpc.Config.BatteryEfficiency
 
 		balance := netSupply - netLoad
@@ -276,14 +302,15 @@ func (mpc *Controller) generateFeasibleDecisions(currentSOC float64, slot TimeSl
 }
 
 // calculateProfit computes the profit for a decision
-// The power balance equation ensures: Solar + GridImport + BatteryDischarge*eff = Load + GridExport + BatteryCharge/eff
-// Therefore, GridImport and GridExport already reflect the effect of battery operations.
+// The power balance equation ensures: Solar + GridImport + BatteryDischarge*eff = Load + GridExport + BatteryCharge/eff + BatteryPreHeat
+// Therefore, GridImport and GridExport already reflect the effect of battery operations and battery preheating.
 // Profit is simply: revenue from exports - cost of imports - degradation cost
+// Note: The battery preheating cost is already included in GridImport when battery is charging at low temperatures
 func (mpc *Controller) calculateProfit(dec ControlDecision, slot TimeSlot) float64 {
 	// Revenue from exporting to grid
 	revenue := dec.GridExport * slot.ExportPrice
 
-	// Cost of importing from grid
+	// Cost of importing from grid (already includes battery preheating consumption when active)
 	importCost := dec.GridImport * slot.ImportPrice
 
 	// Battery degradation cost (wear and tear from cycling)
@@ -292,13 +319,15 @@ func (mpc *Controller) calculateProfit(dec ControlDecision, slot TimeSlot) float
 
 	// Net profit:
 	// + Revenue from exports (GridExport already accounts for battery discharge to grid)
-	// - Cost of imports (GridImport already accounts for battery charging and reduced imports from discharge)
+	// - Cost of imports (GridImport already accounts for battery charging, battery preheating, and reduced imports from discharge)
 	// - Battery degradation (wear and tear cost)
 	//
 	// This correctly incentivizes arbitrage:
 	// - Charging at low import prices reduces profit by importCost
 	// - Discharging at high export prices increases profit by revenue
+	// - When battery temp is low (<10°C), charging incurs additional battery preheating cost (700W)
 	// - The DP optimizer will naturally prefer charge-low/discharge-high strategies
+	// - The optimizer will avoid charging at low temperatures unless prices are very favorable
 	profit := revenue - importCost - degradationCost
 
 	return profit