Update app.py

app.py

@@ -1,6 +1,7 @@
 # ============================================
 # YORK CHILLER OPTIMIZER API
 # Compatible with NumPy 2.0.2 and pandas 2.2.3
+# For 4-Chiller Plants (1000+ TR)
 # ============================================
 
 import os
@@ -23,8 +24,8 @@ import joblib
 import pickle
 
 app = FastAPI(
-    title="York Chiller Energy Optimizer",
-    description="Random Forest Model for Chiller Energy Efficiency - 12 Features",
+    title="York Chiller Energy Optimizer - 4 Chiller Plant Edition",
+    description="Random Forest Model for Chiller Energy Efficiency - 12 Features (1000+ TR Plants)",
     version="2.0.0"
 )
 
@@ -142,9 +143,9 @@ else:
 # ============================================
 
 class ChillerInput(BaseModel):
-    """12 input features exactly matching your model"""
-    total_building_load: float = Field(..., ge=200, le=2500, description="Total building cooling load (RT)")
-    avg_chilled_water_rate: float = Field(..., ge=50, le=500, description="Average chilled water flow rate (L/sec)")
+    """12 input features - optimized for 1000+ TR plants"""
+    total_building_load: float = Field(..., ge=400, le=2500, description="Total building cooling load (RT) - For 4 chiller plant: 400-2500 TR")
+    avg_chilled_water_rate: float = Field(..., ge=200, le=2000, description="Average chilled water flow rate (L/sec)")
     avg_cooling_water_temp: float = Field(..., ge=15, le=35, description="Average cooling water temperature (°C)")
     avg_outside_temp: float = Field(..., ge=32, le=120, description="Average outside air temperature (°F)")
     avg_dew_point: float = Field(..., ge=20, le=80, description="Average dew point temperature (°F)")
@@ -156,13 +157,22 @@ class ChillerInput(BaseModel):
     month: int = Field(..., ge=1, le=12, description="Month of the year (1-12)")
     day_of_year: int = Field(..., ge=1, le=366, description="Day of the year (1-365)")
     
-    # Optional optimization parameters
+    # Optional parameters for 4-chiller plant
     current_chw_setpoint_c: Optional[float] = Field(8.0, ge=5, le=10, description="Current CHW setpoint (°C)")
+    num_chillers_operating: Optional[int] = Field(4, ge=1, le=4, description="Number of chillers currently operating")
+    electricity_rate_usd_per_kwh: Optional[float] = Field(0.12, ge=0.05, le=0.50, description="Electricity rate ($/kWh)")
 
 class PredictionResponse(BaseModel):
     status: str
     kw_per_tr: float
+    total_power_kw: float
+    power_per_chiller_kw: float
+    cooling_load_tr: float
+    load_per_chiller_tr: float
+    cop: float
     efficiency_rating: str
+    plant_summary: Dict[str, Any]
+    annual_cost_estimate: Dict[str, Any]
     features_used: int
     model_type: str
     timestamp: str
@@ -178,8 +188,14 @@ class OptimizationRecommendation(BaseModel):
 class OptimizeResponse(BaseModel):
     timestamp: str
     current_kw_per_tr: float
+    current_total_power_kw: float
     optimal_kw_per_tr: float
+    optimal_total_power_kw: float
     efficiency_improvement_pct: float
+    power_savings_kw: float
+    power_savings_pct: float
+    annual_savings_usd: float
+    co2_reduction_kg_per_year: float
     recommendations: List[OptimizationRecommendation]
     summary: Dict[str, str]
 
@@ -218,11 +234,49 @@ def predict_kw_per_tr(input_data: ChillerInput) -> float:
     # Predict
     prediction = model.predict(features)[0]
     
-    # Clip to realistic range
-    prediction = np.clip(prediction, 0.4, 1.2)
+    # Typical range for large centrifugal chillers (1000+ TR)
+    # Modern efficient: 0.45-0.55 kW/TR
+    # Older units: 0.60-0.80 kW/TR
+    prediction = np.clip(prediction, 0.40, 0.90)
     
     return float(prediction)
 
+def calculate_total_power(kw_per_tr: float, cooling_load_tr: float) -> float:
+    """
+    Calculate total chiller plant power consumption for all chillers
+    
+    Formula: Total Power (kW) = kW/TR × Cooling Load (TR)
+    """
+    return kw_per_tr * cooling_load_tr
+
+def calculate_annual_energy_cost(kw_per_tr: float, avg_load_tr: float, 
+                                  operating_hours: int = 3000, 
+                                  electricity_rate: float = 0.12) -> dict:
+    """
+    Calculate annual energy cost and consumption
+    """
+    avg_power_kw = kw_per_tr * avg_load_tr
+    annual_kwh = avg_power_kw * operating_hours
+    annual_cost_usd = annual_kwh * electricity_rate
+    
+    return {
+        "avg_power_kw": round(avg_power_kw, 1),
+        "annual_kwh": round(annual_kwh / 1000, 1),
+        "annual_cost_usd": round(annual_cost_usd, 0),
+        "operating_hours": operating_hours,
+        "electricity_rate": electricity_rate
+    }
+
+def calculate_cop_from_kw_per_tr(kw_per_tr: float) -> float:
+    """
+    Convert kW/TR to COP (Coefficient of Performance)
+    
+    Formula: COP = 3.516 / kW/TR
+    """
+    if kw_per_tr <= 0:
+        return 0
+    return 3.516 / kw_per_tr
+
 def get_efficiency_rating(kw_per_tr: float) -> str:
     """Get efficiency rating based on kW/TR value"""
     if kw_per_tr < 0.55:
@@ -266,13 +320,14 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> tuple:
 
 @app.get("/")
 async def root():
-    """Root endpoint with API information"""
+    """Root endpoint with API information for large chiller plants"""
     feature_count = len(feature_names) if feature_names and isinstance(feature_names, list) else len(EXPECTED_FEATURES)
     
     return {
-        "service": "York Chiller Energy Optimizer",
+        "service": "York Chiller Energy Optimizer - 4 Chiller Plant Edition",
         "model_type": "Random Forest Regressor",
         "version": "2.0.0",
+        "plant_size": "1000+ TR (4 centrifugal chillers)",
         "status": "online" if model is not None else "model_not_loaded",
         "model_info": {
             "loaded": model is not None,
@@ -284,15 +339,36 @@ async def root():
         "endpoints": {
             "/": "This information",
             "/health": "Health check",
-            "/predict": "POST - Predict efficiency (kW/TR)",
-            "/optimize": "POST - Get optimization recommendations"
+            "/predict": "POST - Predict efficiency and power for 4-chiller plant",
+            "/optimize": "POST - Get optimization with annual savings ($ and CO2)",
+            "/plant-analysis": "POST - Detailed 4-chiller plant analysis"
+        },
+        "sample_4_chiller_input": {
+            "total_building_load": 1200,
+            "avg_chilled_water_rate": 800,
+            "avg_cooling_water_temp": 28,
+            "avg_outside_temp": 95,
+            "avg_dew_point": 65,
+            "avg_humidity": 60,
+            "avg_wind_speed": 8,
+            "avg_pressure": 29.9,
+            "hour": 14,
+            "day_of_week": 2,
+            "month": 7,
+            "day_of_year": 200,
+            "num_chillers_operating": 4,
+            "electricity_rate_usd_per_kwh": 0.12
+        },
+        "expected_output_sample": {
+            "total_power_kw": "~700-800 kW total",
+            "power_per_chiller_kw": "~175-200 kW each",
+            "annual_energy_cost": "$250,000-$350,000 at $0.12/kWh"
         },
         "interpretation": {
-            "kw_per_tr": "Combined energy efficiency - LOWER is better",
-            "excellent": "< 0.55 kW/TR",
-            "good": "0.55-0.65 kW/TR",
-            "fair": "0.65-0.75 kW/TR",
-            "poor": "> 0.75 kW/TR"
+            "kw_per_tr": "Lower is better for 1000+ TR plants: <0.55 = excellent",
+            "total_power_kw": "Actual plant power for all chillers combined",
+            "typical_power_for_1000tr": "500-700 kW at full load",
+            "potential_savings": "50-150 kW possible through optimization = $15k-45k/year"
         }
     }
 
@@ -313,20 +389,61 @@ async def health():
 
 @app.post("/predict", response_model=PredictionResponse)
 async def predict_endpoint(input_data: ChillerInput):
-    """Predict Combined_Kw_per_TR for given conditions"""
+    """Predict efficiency and power for 4-chiller plant (1000+ TR)"""
     try:
         if model is None:
             raise HTTPException(status_code=503, detail="Model not loaded - check logs")
         
+        # Get predicted kW/TR
         kw_per_tr = predict_kw_per_tr(input_data)
+        
+        # Calculate total plant power
+        total_power_kw = calculate_total_power(kw_per_tr, input_data.total_building_load)
+        
+        # Get number of chillers (default 4)
+        num_chillers = input_data.num_chillers_operating or 4
+        
+        # Per-chiller metrics
+        power_per_chiller = total_power_kw / num_chillers
+        load_per_chiller = input_data.total_building_load / num_chillers
+        
+        # Calculate COP
+        cop = calculate_cop_from_kw_per_tr(kw_per_tr)
+        
+        # Get efficiency rating
         rating = get_efficiency_rating(kw_per_tr)
         
+        # Calculate annual cost estimate
+        electricity_rate = input_data.electricity_rate_usd_per_kwh or 0.12
+        annual_cost = calculate_annual_energy_cost(
+            kw_per_tr, 
+            input_data.total_building_load,
+            operating_hours=3000,
+            electricity_rate=electricity_rate
+        )
+        
+        # Plant summary
+        plant_summary = {
+            "num_chillers": num_chillers,
+            "total_capacity_tr": round(input_data.total_building_load, 0),
+            "load_per_chiller_tr": round(load_per_chiller, 1),
+            "power_density_kw_per_100tr": round(kw_per_tr * 100, 2),
+            "chiller_type": "Centrifugal (1000+ TR scale)"
+        }
+        
         feature_count = len(feature_names) if feature_names and isinstance(feature_names, list) else len(EXPECTED_FEATURES)
         
         return PredictionResponse(
             status="success",
             kw_per_tr=round(kw_per_tr, 4),
+            total_power_kw=round(total_power_kw, 1),
+            power_per_chiller_kw=round(power_per_chiller, 1),
+            cooling_load_tr=round(input_data.total_building_load, 1),
+            load_per_chiller_tr=round(load_per_chiller, 1),
+            cop=round(cop, 2),
             efficiency_rating=rating,
+            plant_summary=plant_summary,
+            annual_cost_estimate=annual_cost,
             features_used=feature_count,
             model_type="RandomForestRegressor",
             timestamp=datetime.now().isoformat()
@@ -337,83 +454,130 @@ async def predict_endpoint(input_data: ChillerInput):
 
 @app.post("/optimize", response_model=OptimizeResponse)
 async def optimize_endpoint(input_data: ChillerInput):
-    """Get optimization recommendations"""
+    """Get optimization recommendations for large chiller plant"""
     try:
         if model is None:
             raise HTTPException(status_code=503, detail="Model not loaded - check logs")
         
-        # Current efficiency
-        current_kw = predict_kw_per_tr(input_data)
+        num_chillers = input_data.num_chillers_operating or 4
+        electricity_rate = input_data.electricity_rate_usd_per_kwh or 0.12
+        
+        # Current efficiency and power
+        current_kw_per_tr = predict_kw_per_tr(input_data)
+        current_power_kw = calculate_total_power(current_kw_per_tr, input_data.total_building_load)
         
         # Find optimal setpoint
-        optimal_sp, optimal_kw = optimize_chw_setpoint(input_data)
+        optimal_sp, optimal_kw_per_tr = optimize_chw_setpoint(input_data)
+        optimal_power_kw = calculate_total_power(optimal_kw_per_tr, input_data.total_building_load)
         
         # Calculate savings
-        savings_pct = ((current_kw - optimal_kw) / current_kw) * 100 if current_kw > 0 else 0
+        savings_pct = ((current_kw_per_tr - optimal_kw_per_tr) / current_kw_per_tr) * 100 if current_kw_per_tr > 0 else 0
         savings_pct = max(0, savings_pct)
         
-        # Build recommendations
+        # Power savings
+        power_savings_kw = current_power_kw - optimal_power_kw
+        power_savings_pct = (power_savings_kw / current_power_kw) * 100 if current_power_kw > 0 else 0
+        
+        # Annual savings
+        annual_operating_hours = 3000
+        annual_savings_kwh = power_savings_kw * annual_operating_hours
+        annual_savings_usd = annual_savings_kwh * electricity_rate
+        
+        # CO2 reduction (assuming 0.4 kg CO2 per kWh - US average)
+        co2_reduction_kg = annual_savings_kwh * 0.4
+        
+        # Build recommendations for 4-chiller plant
         recommendations = []
         
+        # Setpoint optimization
         current_sp = input_data.current_chw_setpoint_c or 8.0
         if optimal_sp != current_sp and savings_pct > 1:
             recommendations.append(OptimizationRecommendation(
                 action="CHW Setpoint Optimization",
                 current_value=f"{current_sp:.1f}°C",
                 recommended_value=f"{optimal_sp:.1f}°C",
-                expected_savings=f"{savings_pct:.1f}%",
+                expected_savings=f"{savings_pct:.1f}% ({power_savings_kw:.0f} kW, ${annual_savings_usd:,.0f}/year)",
                 priority="HIGH" if savings_pct > 5 else "MEDIUM",
-                operator_action=f"Adjust CHW setpoint to {optimal_sp:.1f}°C"
+                operator_action=f"Raise CHW setpoint to {optimal_sp:.1f}°C across all {num_chillers} chillers"
             ))
         
-        # Load-based recommendations
-        if input_data.total_building_load < 600:
+        # Chiller sequencing for large plants
+        load_per_chiller = input_data.total_building_load / num_chillers
+        
+        if input_data.total_building_load < 800:
             recommendations.append(OptimizationRecommendation(
                 action="Chiller Sequencing",
-                current_value=f"{input_data.total_building_load:.0f} RT",
-                recommended_value="Single chiller operation",
-                expected_savings="15-25% reduction",
+                current_value=f"{num_chillers} chillers operating",
+                recommended_value="3 chillers (or less)",
+                expected_savings="20-30% power reduction at low load",
                 priority="HIGH",
-                operator_action="Consider operating only one chiller"
+                operator_action=f"Sequentially shut down one chiller, adjust load on remaining {num_chillers-1} chillers"
             ))
         elif input_data.total_building_load > 1800:
             recommendations.append(OptimizationRecommendation(
-                action="Chiller Staging",
-                current_value=f"{input_data.total_building_load:.0f} RT",
-                recommended_value="Verify all chillers",
-                expected_savings="Prevents overload",
-                priority="HIGH",
-                operator_action="Check if all chillers are operating"
+                action="Load Balancing",
+                current_value=f"{load_per_chiller:.0f} TR per chiller",
+                recommended_value="Verify all chillers are contributing equally",
+                expected_savings="5-10% efficiency improvement",
+                priority="MEDIUM",
+                operator_action="Check operating logs for load sharing between chillers"
+            ))
+        
+        # Condenser water temperature optimization
+        if input_data.avg_cooling_water_temp < 24:
+            recommendations.append(OptimizationRecommendation(
+                action="Condenser Water Reset",
+                current_value=f"{input_data.avg_cooling_water_temp:.1f}°C",
+                recommended_value="Allow cooling tower to float higher",
+                expected_savings="3-8% pump energy reduction",
+                priority="MEDIUM",
+                operator_action="Reduce cooling tower fan speed or disable some cells"
             ))
         
         # Free cooling recommendation
         if input_data.avg_outside_temp < 50 and input_data.avg_humidity < 60:
+            estimated_savings_kw = current_power_kw * 0.35
+            estimated_savings_usd = estimated_savings_kw * annual_operating_hours * electricity_rate
             recommendations.append(OptimizationRecommendation(
-                action="Free Cooling",
-                current_value="Not enabled",
-                recommended_value="Consider enabling",
-                expected_savings="20-40%",
+                action="Free Cooling Mode",
+                current_value="Mechanical cooling only",
+                recommended_value="Enable waterside economizer",
+                expected_savings=f"35% (approx {estimated_savings_kw:.0f} kW, ${estimated_savings_usd:,.0f}/year)",
                 priority="HIGH",
-                operator_action="Enable economizer/free cooling"
+                operator_action="Open bypass valve for cooling tower to provide directly chilled water"
             ))
         
         # Efficiency rating
-        rating = get_efficiency_rating(current_kw)
+        rating = get_efficiency_rating(current_kw_per_tr)
+        current_cop = calculate_cop_from_kw_per_tr(current_kw_per_tr)
+        optimal_cop = calculate_cop_from_kw_per_tr(optimal_kw_per_tr)
         
         summary = {
-            "current_efficiency": f"{current_kw:.3f} kW/TR",
-            "optimal_efficiency": f"{optimal_kw:.3f} kW/TR",
-            "potential_savings": f"{savings_pct:.1f}%",
+            "plant_summary": f"{num_chillers} chillers, {input_data.total_building_load:.0f} TR total",
+            "current_efficiency": f"{current_kw_per_tr:.3f} kW/TR (COP: {current_cop:.2f})",
+            "current_power": f"{current_power_kw:.0f} kW ({current_power_kw/num_chillers:.0f} kW per chiller)",
+            "optimal_efficiency": f"{optimal_kw_per_tr:.3f} kW/TR (COP: {optimal_cop:.2f})",
+            "optimal_power": f"{optimal_power_kw:.0f} kW",
+            "power_savings": f"{power_savings_kw:.0f} kW ({savings_pct:.1f}%)",
+            "annual_savings_usd": f"${annual_savings_usd:,.0f}",
+            "co2_reduction": f"{co2_reduction_kg/1000:.1f} metric tons CO2/year",
             "efficiency_rating": rating,
-            "load": f"{input_data.total_building_load:.0f} RT",
-            "recommended_setpoint": f"{optimal_sp:.1f}°C"
+            "load_per_chiller": f"{load_per_chiller:.0f} TR",
+            "recommended_setpoint": f"{optimal_sp:.1f}°C",
+            "electricity_rate": f"${electricity_rate:.2f}/kWh"
         }
         
         return OptimizeResponse(
             timestamp=datetime.now().isoformat(),
-            current_kw_per_tr=round(current_kw, 4),
-            optimal_kw_per_tr=round(optimal_kw, 4),
+            current_kw_per_tr=round(current_kw_per_tr, 4),
+            current_total_power_kw=round(current_power_kw, 1),
+            optimal_kw_per_tr=round(optimal_kw_per_tr, 4),
+            optimal_total_power_kw=round(optimal_power_kw, 1),
             efficiency_improvement_pct=round(savings_pct, 2),
+            power_savings_kw=round(power_savings_kw, 1),
+            power_savings_pct=round(power_savings_pct, 2),
+            annual_savings_usd=round(annual_savings_usd, 0),
+            co2_reduction_kg_per_year=round(co2_reduction_kg, 0),
             recommendations=recommendations,
             summary=summary
         )
@@ -421,6 +585,67 @@ async def optimize_endpoint(input_data: ChillerInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.post("/plant-analysis")
+async def plant_analysis(input_data: ChillerInput):
+    """Detailed analysis for 4-chiller plant"""
+    try:
+        if model is None:
+            raise HTTPException(status_code=503, detail="Model not loaded")
+        
+        kw_per_tr = predict_kw_per_tr(input_data)
+        num_chillers = input_data.num_chillers_operating or 4
+        
+        # Calculate various metrics
+        total_power = kw_per_tr * input_data.total_building_load
+        power_per_chiller = total_power / num_chillers
+        
+        # Compare to industry benchmarks
+        benchmarks = {
+            "excellent": 0.50,
+            "good": 0.60,
+            "average": 0.65,
+            "poor": 0.75
+        }
+        
+        # Energy cost at different loads
+        load_levels = [50, 75, 100]
+        cost_analysis = []
+        for load_pct in load_levels:
+            load_tr = input_data.total_building_load * load_pct / 100
+            power_kw = kw_per_tr * load_tr
+            cost_analysis.append({
+                "load_pct": load_pct,
+                "load_tr": round(load_tr, 0),
+                "power_kw": round(power_kw, 0),
+                "power_per_chiller_kw": round(power_kw / num_chillers, 0)
+            })
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "plant_configuration": {
+                "num_chillers": num_chillers,
+                "total_capacity_tr": input_data.total_building_load,
+                "current_load_tr": input_data.total_building_load,
+                "load_factor": "100%"
+            },
+            "performance_metrics": {
+                "kw_per_tr": round(kw_per_tr, 3),
+                "total_power_kw": round(total_power, 0),
+                "power_per_chiller_kw": round(power_per_chiller, 0),
+                "cop": round(calculate_cop_from_kw_per_tr(kw_per_tr), 2),
+                "vs_benchmark_excellent": f"{((kw_per_tr - benchmarks['excellent'])/benchmarks['excellent']*100):+.1f}%"
+            },
+            "cost_analysis": cost_analysis,
+            "recommendations": [
+                f"Target kW/TR < 0.60 for this plant size (currently {kw_per_tr:.3f})",
+                f"At full load, each chiller draws ~{power_per_chiller:.0f} kW",
+                "Review if all 4 chillers are needed at current load"
+            ]
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)