Update data/calculation.py

data/calculation.py

@@ -7,22 +7,48 @@ Developed by: Dr Majed Abuseif, Deakin University
 
 import numpy as np
 import pandas as pd
-from typing import Dict, List, Optional, NamedTuple
+from typing import Dict, List, Optional, NamedTuple, Any, Tuple
 from enum import Enum
 import streamlit as st
-from data.material_library import Construction, GlazingMaterial, DoorMaterial
+from data.material_library import Construction, GlazingMaterial, DoorMaterial, Material, MaterialLibrary
 from data.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHTING_FIXTURE_TYPES, EQUIPMENT_HEAT_GAINS, VENTILATION_RATES, INFILTRATION_SETTINGS
 from datetime import datetime
 from collections import defaultdict
 import logging
+import math
 from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
-from utils.solar import SolarCalculations
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 class TFMCalculations:
+    # Solar calculation constants (from solar.py)
+    SHGC_COEFFICIENTS = {
+        "Single Clear": [0.1, -0.0, 0.0, -0.0, 0.0, 0.87],
+        "Single Tinted": [0.12, -0.0, 0.0, -0.0, 0.8, -0.0],
+        "Double Clear": [0.14, -0.0, 0.0, -0.0, 0.78, -0.0],
+        "Double Low-E": [0.2, -0.0, 0.0, 0.7, 0.0, -0.0],
+        "Double Tinted": [0.15, -0.0, 0.0, -0.0, 0.65, -0.0],
+        "Double Low-E with Argon": [0.18, -0.0, 0.0, 0.68, 0.0, -0.0],
+        "Single Low-E Reflective": [0.22, -0.0, 0.0, 0.6, 0.0, -0.0],
+        "Double Reflective": [0.24, -0.0, 0.0, 0.58, 0.0, -0.0],
+        "Electrochromic": [0.25, -0.0, 0.5, -0.0, 0.0, -0.0]
+    }
+
+    GLAZING_TYPE_MAPPING = {
+        "Single Clear 3mm": "Single Clear",
+        "Single Clear 6mm": "Single Clear",
+        "Single Tinted 6mm": "Single Tinted",
+        "Double Clear 6mm/13mm Air": "Double Clear",
+        "Double Low-E 6mm/13mm Air": "Double Low-E",
+        "Double Tinted 6mm/13mm Air": "Double Tinted",
+        "Double Low-E 6mm/13mm Argon": "Double Low-E with Argon",
+        "Single Low-E Reflective 6mm": "Single Low-E Reflective",
+        "Double Reflective 6mm/13mm Air": "Double Reflective",
+        "Electrochromic 6mm/13mm Air": "Electrochromic"
+    }
+
     @staticmethod
     def calculate_conduction_load(component, outdoor_temp: float, indoor_temp: float, hour: int, mode: str = "none") -> tuple[float, float]:
         """Calculate conduction load for heating and cooling in kW based on mode."""
@@ -48,6 +74,222 @@ class TFMCalculations:
         heating_load = -load / 1000 if mode == "heating" else 0
         return cooling_load, heating_load
 
+    @staticmethod
+    def day_of_year(month: int, day: int, year: int) -> int:
+        """Calculate day of the year (n) from month, day, and year, accounting for leap years.
+
+        Args:
+            month (int): Month of the year (1-12).
+            day (int): Day of the month (1-31).
+            year (int): Year.
+
+        Returns:
+            int: Day of the year (1-365 or 366 for leap years).
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 18.
+        """
+        days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
+            days_in_month[1] = 29
+        return sum(days_in_month[:month-1]) + day
+
+    @staticmethod
+    def equation_of_time(n: int) -> float:
+        """Calculate Equation of Time (EOT) in minutes using Spencer's formula.
+
+        Args:
+            n (int): Day of the year (1-365 or 366).
+
+        Returns:
+            float: Equation of Time in minutes.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 18.
+        """
+        B = (n - 1) * 360 / 365
+        B_rad = math.radians(B)
+        EOT = 229.2 * (0.000075 + 0.001868 * math.cos(B_rad) - 0.032077 * math.sin(B_rad) -
+                       0.014615 * math.cos(2 * B_rad) - 0.04089 * math.sin(2 * B_rad))
+        return EOT
+
+    @staticmethod
+    def calculate_dynamic_shgc(glazing_type: str, cos_theta: float) -> float:
+        """Calculate dynamic SHGC based on incidence angle.
+
+        Args:
+            glazing_type (str): Type of glazing (e.g., 'Single Clear').
+            cos_theta (float): Cosine of the angle of incidence.
+
+        Returns:
+            float: Dynamic SHGC value.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 15, Table 13.
+        """
+        if glazing_type not in TFMCalculations.SHGC_COEFFICIENTS:
+            logger.warning(f"Unknown glazing type '{glazing_type}'. Using default SHGC coefficients for Single Clear.")
+            glazing_type = "Single Clear"
+        
+        c = TFMCalculations.SHGC_COEFFICIENTS[glazing_type]
+        # Incidence angle modifier: f(cos(θ)) = c_0 + c_1·cos(θ) + c_2·cos²(θ) + c_3·cos³(θ) + c_4·cos⁴(θ) + c_5·cos⁵(θ)
+        f_cos_theta = (c[0] + c[1] * cos_theta + c[2] * cos_theta**2 +
+                       c[3] * cos_theta**3 + c[4] * cos_theta**4 + c[5] * cos_theta**5)
+        return f_cos_theta
+
+    @staticmethod
+    def get_surface_parameters(component: Any, building_info: Dict, material_library: MaterialLibrary, 
+                             project_materials: Dict, project_constructions: Dict, 
+                             project_glazing_materials: Dict, project_door_materials: Dict) -> Tuple[float, float, float, Optional[float], float]:
+        """
+        Determine surface parameters (tilt, azimuth, h_o, emissivity, solar_absorption) for a component.
+        Uses MaterialLibrary to fetch properties from first layer for walls/roofs, DoorMaterial for doors,
+        and GlazingMaterial for windows/skylights. Handles orientation and tilt based on component type:
+        - Walls, Doors, Windows: Azimuth = facade base azimuth + component.rotation; Tilt = 90°.
+        - Roofs, Skylights: Azimuth = component.orientation; Tilt = component.tilt (default 180°).
+        
+        Args:
+            component: Component object with component_type, facade, rotation, orientation, tilt,
+                      construction, glazing_material, or door_material.
+            building_info (Dict): Building information containing orientation_angle for facade mapping.
+            material_library: MaterialLibrary instance for accessing library materials/constructions.
+            project_materials: Dict of project-specific Material objects.
+            project_constructions: Dict of project-specific Construction objects.
+            project_glazing_materials: Dict of project-specific GlazingMaterial objects.
+            project_door_materials: Dict of project-specific DoorMaterial objects.
+
+        Returns:
+            Tuple[float, float, float, Optional[float], float]: Surface tilt (°), surface azimuth (°),
+            h_o (W/m²·K), emissivity, solar_absorption.
+
+        Raises:
+            ValueError: If facade is missing or invalid for walls, doors, or windows.
+        """
+        # Default parameters
+        if component.component_type == ComponentType.ROOF:
+            surface_tilt = getattr(component, 'tilt', 180.0)  # Horizontal, downward if tilt absent
+            h_o = 23.0  # W/m²·K for roofs
+        elif component.component_type == ComponentType.SKYLIGHT:
+            surface_tilt = getattr(component, 'tilt', 180.0)  # Horizontal, downward if tilt absent
+            h_o = 23.0  # W/m²·K for skylights
+        elif component.component_type == ComponentType.FLOOR:
+            surface_tilt = 0.0  # Horizontal, upward
+            h_o = 17.0  # W/m²·K
+        else:  # WALL, DOOR, WINDOW
+            surface_tilt = 90.0  # Vertical
+            h_o = 17.0  # W/m²·K
+
+        emissivity = 0.9  # Default for opaque components
+        solar_absorption = 0.6  # Default
+        shgc = None  # Only for windows/skylights
+
+        try:
+            # Determine surface azimuth
+            if component.component_type in [ComponentType.ROOF, ComponentType.SKYLIGHT]:
+                # Use component's orientation attribute directly, ignoring facade
+                surface_azimuth = getattr(component, 'orientation', 0.0)
+                logger.debug(f"Using component orientation for {component.id}: "
+                            f"azimuth={surface_azimuth}, tilt={surface_tilt}")
+            else:  # WALL, DOOR, WINDOW
+                # Check for facade attribute
+                facade = getattr(component, 'facade', None)
+                if not facade:
+                    component_id = getattr(component, 'id', 'unknown_component')
+                    raise ValueError(f"Component {component_id} is missing 'facade' field")
+
+                # Define facade azimuths based on building orientation_angle
+                base_azimuth = building_info.get("orientation_angle", 0.0)
+                facade_angles = {
+                    "A": base_azimuth,
+                    "B": (base_azimuth + 90.0) % 360,
+                    "C": (base_azimuth + 180.0) % 360,
+                    "D": (base_azimuth + 270.0) % 360
+                }
+
+                if facade not in facade_angles:
+                    component_id = getattr(component, 'id', 'unknown_component')
+                    raise ValueError(f"Invalid facade '{facade}' for component {component_id}. "
+                                    f"Expected one of {list(facade_angles.keys())}")
+
+                # Add component rotation to facade azimuth
+                surface_azimuth = (facade_angles[facade] + getattr(component, 'rotation', 0.0)) % 360
+                logger.debug(f"Component {component.id}: facade={facade}, "
+                            f"base_azimuth={facade_angles[facade]}, rotation={getattr(component, 'rotation', 0.0)}, "
+                            f"total_azimuth={surface_azimuth}, tilt={surface_tilt}")
+
+            # Fetch material properties
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                construction = getattr(component, 'construction', None)
+                if not construction:
+                    logger.warning(f"No construction defined for {component.id}. "
+                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                else:
+                    # Get construction from library or project
+                    construction_obj = (project_constructions.get(construction.name) or
+                                        material_library.library_constructions.get(construction.name))
+                    if not construction_obj:
+                        logger.error(f"Construction '{construction.name}' not found for {component.id}.")
+                    elif not construction_obj.layers:
+                        logger.warning(f"No layers in construction '{construction.name}' for {component.id}.")
+                    else:
+                        # Use first (outermost) layer's properties
+                        first_layer = construction_obj.layers[0]
+                        material = first_layer["material"]
+                        solar_absorption = material.solar_absorption
+                        emissivity = material.emissivity
+                        logger.debug(f"Using first layer material '{material.name}' for {component.id}: "
+                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
+
+            elif component.component_type == ComponentType.DOOR:
+                door_material = getattr(component, 'door_material', None)
+                if not door_material:
+                    logger.warning(f"No door material defined for {component.id}. "
+                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                else:
+                    # Get door material from library or project
+                    door_material_obj = (project_door_materials.get(door_material.name) or
+                                         material_library.library_door_materials.get(door_material.name))
+                    if not door_material_obj:
+                        logger.error(f"Door material '{door_material.name}' not found for {component.id}.")
+                    else:
+                        solar_absorption = door_material_obj.solar_absorption
+                        emissivity = door_material_obj.emissivity
+                        logger.debug(f"Using door material '{door_material_obj.name}' for {component.id}: "
+                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
+
+            elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                glazing_material = getattr(component, 'glazing_material', None)
+                if not glazing_material:
+                    logger.warning(f"No glazing material defined for {component.id}. "
+                                  f"Using default SHGC=0.7, h_o={h_o}.")
+                    shgc = 0.7
+                else:
+                    # Get glazing material from library or project
+                    glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
+                                            material_library.library_glazing_materials.get(glazing_material.name))
+                    if not glazing_material_obj:
+                        logger.error(f"Glazing material '{glazing_material.name}' not found for {component.id}.")
+                        shgc = 0.7
+                    else:
+                        shgc = glazing_material_obj.shgc
+                        h_o = glazing_material_obj.h_o
+                        logger.debug(f"Using glazing material '{glazing_material_obj.name}' for {component.id}: "
+                                    f"shgc={shgc}, h_o={h_o}")
+                emissivity = None  # Not used for glazing
+
+        except Exception as e:
+            component_id = getattr(component, 'id', 'unknown_component')
+            logger.error(f"Error retrieving surface parameters for {component_id}: {str(e)}")
+            # Apply defaults
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                solar_absorption = 0.6
+                emissivity = 0.9
+            else:  # WINDOW, SKYLIGHT
+                shgc = 0.7
+                # h_o retains default from component type
+
+        return surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption
+
     @staticmethod
     def calculate_solar_load(component, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
         """Calculate solar load in kW (cooling only) using ASHRAE-compliant solar calculations.
@@ -69,19 +311,16 @@ class TFMCalculations:
             return 0
 
         try:
-            # Initialize SolarCalculations with MaterialLibrary from session state
+            # Get MaterialLibrary and project-specific data from session state
             material_library = st.session_state.get("material_library")
             if not material_library:
                 logger.error("MaterialLibrary not found in session_state")
                 raise ValueError("MaterialLibrary not found in session_state")
             
-            solar_calc = SolarCalculations(
-                material_library=material_library,
-                project_materials=st.session_state.get("project_materials", {}),
-                project_constructions=st.session_state.get("project_constructions", {}),
-                project_glazing_materials=st.session_state.get("project_glazing_materials", {}),
-                project_door_materials=st.session_state.get("project_door_materials", {})
-            )
+            project_materials = st.session_state.get("project_materials", {})
+            project_constructions = st.session_state.get("project_constructions", {})
+            project_glazing_materials = st.session_state.get("project_glazing_materials", {})
+            project_door_materials = st.session_state.get("project_door_materials", {})
 
             # Get location parameters from climate_data
             climate_data = st.session_state.get("climate_data", {})
@@ -89,16 +328,22 @@ class TFMCalculations:
             longitude = climate_data.get("longitude", 0.0)
             timezone = climate_data.get("time_zone", 0.0)
 
-            # Get ground reflectivity (default 0.2, to be added to session_state later)
+            # Get ground reflectivity (default 0.2)
             ground_reflectivity = st.session_state.get("ground_reflectivity", 0.2)
 
-            # Prepare components dictionary for SolarCalculations
-            components = {
-                "fenestration": [component],  # Single component for this call
-                "_building_info": {
-                    "A": {"azimuth": building_orientation, "tilt_angle": 0.0}
-                }
-            }
+            # Validate input parameters
+            if not -90 <= latitude <= 90:
+                logger.warning(f"Invalid latitude {latitude}. Using default 0.0.")
+                latitude = 0.0
+            if not -180 <= longitude <= 180:
+                logger.warning(f"Invalid longitude {longitude}. Using default 0.0.")
+                longitude = 0.0
+            if not -12 <= timezone <= 14:
+                logger.warning(f"Invalid timezone {timezone}. Using default 0.0.")
+                timezone = 0.0
+            if not 0 <= ground_reflectivity <= 1:
+                logger.warning(f"Invalid ground_reflectivity {ground_reflectivity}. Using default 0.2.")
+                ground_reflectivity = 0.2
 
             # Ensure hourly_data has required fields
             required_fields = ["month", "day", "hour", "global_horizontal_radiation", "direct_normal_radiation", 
@@ -112,33 +357,109 @@ class TFMCalculations:
                 logger.info(f"No solar load for hour {hour} due to GHI={hourly_data['global_horizontal_radiation']}")
                 return 0
 
-            # Call calculate_solar_parameters for this hour
-            results = solar_calc.calculate_solar_parameters(
-                hourly_data=[hourly_data],  # Single record as list
-                latitude=latitude,
-                longitude=longitude,
-                timezone=timezone,
-                ground_reflectivity=ground_reflectivity,
-                components=components
-            )
-
-            # Extract solar heat gain for the component
-            if not results:
-                logger.warning(f"No solar results for hour {hour}")
-                return 0
+            # Extract weather data
+            month = hourly_data["month"]
+            day = hourly_data["day"]
+            hour = hourly_data["hour"]
+            ghi = hourly_data["global_horizontal_radiation"]
+            dni = hourly_data.get("direct_normal_radiation", ghi * 0.7)  # Fallback: estimate DNI
+            dhi = hourly_data.get("diffuse_horizontal_radiation", ghi * 0.3)  # Fallback: estimate DHI
+            outdoor_temp = hourly_data["dry_bulb"]
 
-            result = results[0]  # Single hour
-            for comp_result in result.get("component_results", []):
-                if comp_result["component_id"] == getattr(component, 'id', 'unknown_component'):
-                    solar_heat_gain = comp_result.get("solar_heat_gain", 0.0)
-                    logger.info(f"Solar load for component {comp_result['component_id']} at hour {hour}: {solar_heat_gain:.2f} kW")
-                    return solar_heat_gain
+            if ghi < 0 or dni < 0 or dhi < 0:
+                logger.error(f"Negative radiation values for {month}/{day}/{hour}")
+                raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
 
-            logger.warning(f"No matching component found in solar results for hour {hour}")
-            return 0
+            logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
+                       f"dry_bulb={outdoor_temp}")
+
+            # Step 1: Local Solar Time (LST) with Equation of Time
+            year = 2025  # Fixed year since not provided
+            n = TFMCalculations.day_of_year(month, day, year)
+            EOT = TFMCalculations.equation_of_time(n)
+            lambda_std = 15 * timezone  # Standard meridian longitude (°)
+            standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
+            LST = standard_time + (4 * (lambda_std - longitude) + EOT) / 60 
+
+            # Step 2: Solar Declination (δ)
+            delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
+
+            # Step 3: Hour Angle (HRA)
+            hra = 15 * (LST - 12)
+
+            # Step 4: Solar Altitude (α) and Azimuth (ψ)
+            phi = math.radians(latitude)
+            delta_rad = math.radians(delta)
+            hra_rad = math.radians(hra)
+
+            sin_alpha = math.sin(phi) * math.sin(delta_rad) + math.cos(phi) * math.cos(delta_rad) * math.cos(hra_rad)
+            alpha = math.degrees(math.asin(sin_alpha))
+
+            if abs(math.cos(math.radians(alpha))) < 0.01:
+                azimuth = 0  # North at sunrise/sunset
+            else:
+                sin_az = math.cos(delta_rad) * math.sin(hra_rad) / math.cos(math.radians(alpha))
+                cos_az = (sin_alpha * math.sin(phi) - math.sin(delta_rad)) / (math.cos(math.radians(alpha)) * math.cos(phi))
+                azimuth = math.degrees(math.atan2(sin_az, cos_az))
+                if hra > 0:  # Afternoon
+                    azimuth = 360 - azimuth if azimuth > 0 else -azimuth
+
+            logger.info(f"Solar angles for {month}/{day}/{hour}: declination={delta:.2f}, LST={LST:.2f}, "
+                       f"HRA={hra:.2f}, altitude={alpha:.2f}, azimuth={azimuth:.2f}")
+
+            # Step 5: Get surface parameters
+            building_info = {"orientation_angle": building_orientation}
+            surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption = \
+                TFMCalculations.get_surface_parameters(
+                    component, building_info, material_library, project_materials,
+                    project_constructions, project_glazing_materials, project_door_materials
+                )
+
+            # For windows/skylights, get SHGC from material
+            shgc = 0.7  # Default
+            if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                glazing_material = getattr(component, 'glazing_material', None)
+                if glazing_material:
+                    glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
+                                           material_library.library_glazing_materials.get(glazing_material.name))
+                    if glazing_material_obj:
+                        shgc = glazing_material_obj.shgc
+                        h_o = glazing_material_obj.h_o
+                    else:
+                        logger.warning(f"Glazing material '{glazing_material.name}' not found for {component.id}. Using default SHGC=0.7.")
+                else:
+                    logger.warning(f"No glazing material defined for {component.id}. Using default SHGC=0.7.")
+
+            # Step 6: Calculate angle of incidence (θ)
+            cos_theta = (math.sin(math.radians(alpha)) * math.cos(math.radians(surface_tilt)) +
+                         math.cos(math.radians(alpha)) * math.sin(math.radians(surface_tilt)) *
+                         math.cos(math.radians(azimuth - surface_azimuth)))
+            cos_theta = max(min(cos_theta, 1.0), 0.0)  # Clamp to [0, 1]
+
+            logger.info(f"  Component {getattr(component, 'id', 'unknown_component')} at {month}/{day}/{hour}: "
+                        f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
+                        f"cos_theta={cos_theta:.2f}")
+
+            # Step 7: Calculate total incident radiation (I_t)
+            view_factor = (1 - math.cos(math.radians(surface_tilt))) / 2
+            ground_reflected = ground_reflectivity * ghi * view_factor
+            I_t = dni * cos_theta + dhi + ground_reflected
+
+            # Step 8: Calculate solar heat gain for fenestration
+            glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING.get(component.name, 'Single Clear')
+            iac = getattr(component, 'iac', 1.0)  # Default internal shading
+            shgc_dynamic = shgc * TFMCalculations.calculate_dynamic_shgc(glazing_type, cos_theta)
+            solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000  # kW
+
+            logger.info(f"Solar heat gain for {getattr(component, 'id', 'unknown_component')} at {month}/{day}/{hour}: "
+                        f"{solar_heat_gain:.2f} kW (area={component.area}, shgc_dynamic={shgc_dynamic:.2f}, "
+                        f"I_t={I_t:.2f}, iac={iac})")
+            
+            return solar_heat_gain
 
         except Exception as e:
-            logger.error(f"Error calculating solar load for component {getattr(component, 'id', 'unknown_component')} at hour {hour}: {str(e)}")
+            component_id = getattr(component, 'id', 'unknown_component')
+            logger.error(f"Error calculating solar load for component {component_id} at hour {hour}: {str(e)}")
             return 0
 
     @staticmethod