Update app/hvac_loads.py

app/hvac_loads.py

@@ -22,6 +22,50 @@ from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+class AdaptiveComfortModel:
+    @staticmethod
+    def compute_daily_mean_temperatures(hourly_data: List[Dict]) -> List[Tuple[Tuple[int, int], float]]:
+        daily_means = {}
+        for data in hourly_data:
+            key = (data["month"], data["day"])
+            daily_means.setdefault(key, []).append(data["dry_bulb"])
+        return [(key, np.mean(values)) for key, values in sorted(daily_means.items())]
+
+    @staticmethod
+    def compute_running_mean(daily_means: List[float], alpha: float = 0.8) -> List[float]:
+        trm = []
+        for i, t in enumerate(daily_means):
+            if i == 0:
+                trm.append(t)
+            else:
+                trm.append((1 - alpha) * t + alpha * trm[i - 1])
+        return trm
+
+    @staticmethod
+    def generate_adaptive_setpoints(hourly_data: List[Dict], acceptability: str = "90") -> Dict[Tuple[int, int], float]:
+        daily_mean_data = AdaptiveComfortModel.compute_daily_mean_temperatures(hourly_data)
+        daily_keys = [key for key, _ in daily_mean_data]
+        daily_values = [value for _, value in daily_mean_data]
+        running_means = AdaptiveComfortModel.compute_running_mean(daily_values)
+
+        setpoints = {}
+        for i, key in enumerate(daily_keys):
+            trm = running_means[i]
+            if acceptability == "80":
+                t_min = 0.31 * trm + 13.5
+                t_max = 0.31 * trm + 22.5
+            elif acceptability == "85":
+                t_min = 0.31 * trm + 13.9
+                t_max = 0.31 * trm + 22.1
+            elif acceptability == "95":
+                t_min = 0.31 * trm + 14.7
+                t_max = 0.31 * trm + 20.7
+            else:  # Default to 90%
+                t_min = 0.31 * trm + 14.3
+                t_max = 0.31 * trm + 21.3
+            setpoints[key] = (t_min + t_max) / 2
+        return setpoints
+
 class TFMCalculations:
     # Solar calculation constants (from utils/solar.py)
     SHGC_COEFFICIENTS = {
@@ -632,7 +676,8 @@ class TFMCalculations:
 
     @staticmethod
     def get_adaptive_comfort_temp(outdoor_temp: float) -> float:
-        """Calculate adaptive comfort temperature per ASHRAE 55."""
+        """Deprecated: Use AdaptiveComfortModel instead."""
+        logger.warning("get_adaptive_comfort_temp is deprecated. Use AdaptiveComfortModel.generate_adaptive_setpoints.")
         if 10 <= outdoor_temp <= 33.5:
             return 0.31 * outdoor_temp + 17.8
         return 24.0
@@ -662,9 +707,9 @@ class TFMCalculations:
         return filtered_data
 
     @staticmethod
-    def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float) -> Dict:
+    def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float, month: int = 1, day: int = 1, adaptive_setpoints: Optional[Dict[Tuple[int, int], float]] = None) -> Dict:
         """Determine indoor conditions based on user settings."""
-        if indoor_conditions["type"] == "Fixed":
+        if indoor_conditions["type"] == "Fixed Setpoints":
             mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
             if mode == "cooling":
                 return {
@@ -678,16 +723,10 @@ class TFMCalculations:
                 }
             else:
                 return {"temperature": 24.0, "rh": 50.0}
-        elif indoor_conditions["type"] == "Time-varying":
-            schedule = indoor_conditions.get("schedule", [])
-            if schedule:
-                hour_idx = hour % 24
-                for entry in schedule:
-                    if entry["hour"] == hour_idx:
-                        return {"temperature": entry["temperature"], "rh": entry["rh"]}
-            return {"temperature": 24.0, "rh": 50.0}
         else:  # Adaptive
-            return {"temperature": TFMCalculations.get_adaptive_comfort_temp(outdoor_temp), "rh": 50.0}
+            key = (month, day)
+            temp = adaptive_setpoints.get(key, 24.0) if adaptive_setpoints else 24.0
+            return {"temperature": temp, "rh": 50.0}
 
     @staticmethod
     def calculate_tfm_loads(components: Dict, hourly_data: List[Dict], indoor_conditions: Dict, internal_loads: Dict, building_info: Dict, sim_period: Dict, hvac_settings: Dict) -> List[Dict]:
@@ -703,6 +742,12 @@ class TFMCalculations:
             st.session_state.material_library = MaterialLibrary()
             logger.info("Initialized MaterialLibrary in session_state for solar calculations")
         
+        if indoor_conditions["type"] == "Adaptive":
+            acceptability = indoor_conditions.get("adaptive_acceptability", "90")
+            adaptive_setpoints = AdaptiveComfortModel.generate_adaptive_setpoints(hourly_data, acceptability)
+        else:
+            adaptive_setpoints = None
+
         for comp_list in components.values():
             for comp in comp_list:
                 comp['ctf'] = CTFCalculator.calculate_ctf_coefficients(comp)
@@ -711,7 +756,9 @@ class TFMCalculations:
         for hour_data in filtered_data:
             hour = hour_data["hour"]
             outdoor_temp = hour_data["dry_bulb"]
-            indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp)
+            month = hour_data["month"]
+            day = hour_data["day"]
+            indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp, month, day, adaptive_setpoints)
             indoor_temp = indoor_cond["temperature"]
             conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
             is_operating = False
@@ -755,8 +802,8 @@ class TFMCalculations:
                 total_cooling = 0
             temp_loads.append({
                 "hour": hour,
-                "month": hour_data["month"],
-                "day": hour_data["day"],
+                "month": month,
+                "day": day,
                 "conduction_cooling": conduction_cooling,
                 "conduction_heating": conduction_heating,
                 "solar": solar,
@@ -838,13 +885,13 @@ def display_hvac_loads_page():
         st.subheader("Indoor Conditions")
         indoor_type = st.selectbox(
             "Indoor Conditions Type",
-            ["Fixed", "Time-varying", "Adaptive"],
+            ["Fixed Setpoints", "Adaptive"],
             key="hvac_indoor_type",
-            index=["Fixed", "Time-varying", "Adaptive"].index(st.session_state.project_data["indoor_conditions"]["type"])
+            index=["Fixed Setpoints", "Adaptive"].index(st.session_state.project_data["indoor_conditions"]["type"])
         )
         st.session_state.project_data["indoor_conditions"]["type"] = indoor_type
 
-        if indoor_type == "Fixed":
+        if indoor_type == "Fixed Setpoints":
             col1, col2 = st.columns(2)
             with col1:
                 cooling_temp = st.number_input(
@@ -888,33 +935,14 @@ def display_hvac_loads_page():
                 "temperature": heating_temp,
                 "rh": heating_rh
             }
-        elif indoor_type == "Time-varying":
-            st.write("Define hourly temperature and RH schedule (0-23 hours):")
-            schedule = []
-            for hour in range(24):
-                with st.container():
-                    st.markdown(f"**Hour {hour}**")
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        temp = st.number_input(
-                            f"Temperature (°C)",
-                            min_value=16.0,
-                            max_value=30.0,
-                            value=24.0,
-                            step=0.1,
-                            key=f"hvac_schedule_temp_{hour}"
-                        )
-                    with col2:
-                        rh = st.number_input(
-                            f"Relative Humidity (%)",
-                            min_value=30.0,
-                            max_value=70.0,
-                            value=50.0,
-                            step=1.0,
-                            key=f"hvac_schedule_rh_{hour}"
-                        )
-                    schedule.append({"hour": hour, "temperature": temp, "rh": rh})
-            st.session_state.project_data["indoor_conditions"]["schedule"] = schedule
+        elif indoor_type == "Adaptive":
+            acceptability = st.selectbox(
+                "Adaptive Comfort Acceptability (%)",
+                ["80", "85", "90", "95"],
+                index=["80", "85", "90", "95"].index(st.session_state.project_data["indoor_conditions"].get("adaptive_acceptability", "90")),
+                key="adaptive_acceptability"
+            )
+            st.session_state.project_data["indoor_conditions"]["adaptive_acceptability"] = acceptability
 
         # HVAC Settings Configuration
         st.subheader("HVAC Settings")