Upload 2 files

utils/ctf_calculations.py

@@ -0,0 +1,230 @@
+"""
+CTF Calculations Module
+
+This module contains the CTFCalculator class for calculating Conduction Transfer Function (CTF)
+coefficients for HVAC load calculations using the implicit Finite Difference Method.
+
+Developed by: Dr Majed Abuseif, Deakin University
+© 2025
+"""
+
+import numpy as np
+import scipy.sparse as sparse
+import scipy.sparse.linalg as sparse_linalg
+import hashlib
+import logging
+import threading
+from typing import List
+from data.material_library import Construction
+from enum import Enum
+from typing import Dict, List, Optional, NamedTuple
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class ComponentType(Enum):
+    WALL = "Wall"
+    ROOF = "Roof"
+    FLOOR = "Floor"
+    WINDOW = "Window"
+    DOOR = "Door"
+    SKYLIGHT = "Skylight"
+
+class CTFCoefficients(NamedTuple):
+    X: List[float]  # Exterior temperature coefficients
+    Y: List[float]  # Cross coefficients
+    Z: List[float]  # Interior temperature coefficients
+    F: List[float]  # Flux history coefficients
+
+class CTFCalculator:
+    """Class to calculate and cache CTF coefficients for building components."""
+    
+    # Cache for CTF coefficients based on construction properties
+    _ctf_cache = {}
+    _cache_lock = threading.Lock()  # Thread-safe lock for cache access
+
+    @staticmethod
+    def _hash_construction(construction: Construction) -> str:
+        """Generate a unique hash for a construction based on its properties.
+
+        Args:
+            construction: Construction object containing material layers.
+
+        Returns:
+            str: SHA-256 hash of the construction properties.
+        """
+        hash_input = f"{construction.name}"
+        for layer in construction.layers:
+            material = layer["material"]
+            hash_input += f"{material.name}{material.conductivity}{material.density}{material.specific_heat}{layer['thickness']}"
+        return hashlib.sha256(hash_input.encode()).hexdigest()
+
+    @classmethod
+    def calculate_ctf_coefficients(cls, component) -> CTFCoefficients:
+        """Calculate CTF coefficients using implicit Finite Difference Method.
+
+        Note: Per ASHRAE, CTF calculations are skipped for WINDOW, DOOR, and SKYLIGHT components,
+        as they use typical material properties. CTF tables for these components will be added later.
+
+        Args:
+            component: Building component with construction properties.
+
+        Returns:
+            CTFCoefficients: Named tuple containing X, Y, Z, and F coefficients.
+        """
+        # Skip CTF for WINDOW, DOOR, SKYLIGHT as per ASHRAE; return zero coefficients
+        if component.component_type in [ComponentType.WINDOW, ComponentType.DOOR, ComponentType.SKYLIGHT]:
+            logger.info(f"Skipping CTF calculation for {component.component_type.value} component '{component.name}'. Using zero coefficients until CTF tables are implemented.")
+            return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
+
+        # Check if construction exists and has layers
+        construction = component.construction
+        if not construction or not construction.layers:
+            logger.warning(f"No valid construction or layers for component '{component.name}' ({component.component_type.value}). Returning zero CTFs.")
+            return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
+
+        # Check cache with thread-safe access
+        construction_hash = cls._hash_construction(construction)
+        with cls._cache_lock:
+            if construction_hash in cls._ctf_cache:
+                logger.info(f"Using cached CTF coefficients for construction {construction.name}")
+                return cls._ctf_cache[construction_hash]
+
+        # Discretization parameters
+        dt = 3600  # 1-hour time step (s)
+        nodes_per_layer = 3  # 2–4 nodes per layer for balance
+        R_out = 0.04  # Outdoor surface resistance (m²·K/W, ASHRAE)
+        R_in = 0.12   # Indoor surface resistance (m²·K/W, ASHRAE)
+
+        # Collect layer properties
+        thicknesses = [layer["thickness"] for layer in construction.layers]
+        materials = [layer["material"] for layer in construction.layers]
+        k = [m.conductivity for m in materials]  # W/m·K
+        rho = [m.density for m in materials]    # kg/m³
+        c = [m.specific_heat for m in materials]  # J/kg·K
+        alpha = [k_i / (rho_i * c_i) for k_i, rho_i, c_i in zip(k, rho, c)]  # Thermal diffusivity (m²/s)
+
+        # Calculate node spacing and check stability
+        total_nodes = sum(nodes_per_layer for _ in thicknesses)
+        dx = [t / nodes_per_layer for t in thicknesses]  # Node spacing per layer
+        node_positions = []
+        node_idx = 0
+        for i, t in enumerate(thicknesses):
+            for j in range(nodes_per_layer):
+                node_positions.append((i, j, node_idx))  # (layer_idx, node_in_layer, global_node_idx)
+                node_idx += 1
+
+        # Stability check: Fourier number
+        for i, (a, d) in enumerate(zip(alpha, dx)):
+            Fo = a * dt / (d ** 2)
+            if Fo < 0.33:
+                logger.warning(f"Fourier number {Fo:.3f} < 0.33 for layer {i} ({materials[i].name}). Adjusting node spacing.")
+                dx[i] = np.sqrt(a * dt / 0.33)
+                nodes_per_layer = max(2, int(np.ceil(thicknesses[i] / dx[i])))
+                dx[i] = thicknesses[i] / nodes_per_layer
+                Fo = a * dt / (dx[i] ** 2)
+                logger.info(f"Adjusted node spacing for layer {i}: dx={dx[i]:.4f} m, Fo={Fo:.3f}")
+
+        # Build system matrices
+        A = sparse.lil_matrix((total_nodes, total_nodes))
+        b = np.zeros(total_nodes)
+        node_to_layer = [i for i, _, _ in node_positions]
+
+        for idx, (layer_idx, node_j, global_idx) in enumerate(node_positions):
+            k_i = k[layer_idx]
+            rho_i = rho[layer_idx]
+            c_i = c[layer_idx]
+            dx_i = dx[layer_idx]
+
+            if node_j == 0 and layer_idx == 0:  # Outdoor surface node
+                A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) + dt / (rho_i * c_i * dx_i * R_out)
+                A[idx, idx + 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
+                b[idx] = dt / (rho_i * c_i * dx_i * R_out)  # Outdoor temp contribution
+            elif node_j == nodes_per_layer - 1 and layer_idx == len(thicknesses) - 1:  # Indoor surface node
+                A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) + dt / (rho_i * c_i * dx_i * R_in)
+                A[idx, idx - 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
+                b[idx] = dt / (rho_i * c_i * dx_i * R_in)  # Indoor temp contribution
+            elif node_j == nodes_per_layer - 1 and layer_idx < len(thicknesses) - 1:  # Interface between layers
+                k_next = k[layer_idx + 1]
+                dx_next = dx[layer_idx + 1]
+                rho_next = rho[layer_idx + 1]
+                c_next = c[layer_idx + 1]
+                A[idx, idx] = 1.0 + dt * (k_i / dx_i + k_next / dx_next) / (0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
+                A[idx, idx - 1] = -dt * k_i / (dx_i * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
+                A[idx, idx + 1] = -dt * k_next / (dx_next * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
+            elif node_j == 0 and layer_idx > 0:  # Interface from previous layer
+                k_prev = k[layer_idx - 1]
+                dx_prev = dx[layer_idx - 1]
+                rho_prev = rho[layer_idx - 1]
+                c_prev = c[layer_idx - 1]
+                A[idx, idx] = 1.0 + dt * (k_prev / dx_prev + k_i / dx_i) / (0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+                A[idx, idx - 1] = -dt * k_prev / (dx_prev * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+                A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+            else:  # Internal node
+                A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
+                A[idx, idx - 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i)
+                A[idx, idx + 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i)
+
+        A = A.tocsr()  # Convert to CSR for efficient solving
+
+        # Calculate CTF coefficients (X, Y, Z, F)
+        num_ctf = 12  # Standard number of coefficients
+        X = [0.0] * num_ctf  # Exterior temp response
+        Y = [0.0] * num_ctf  # Cross response
+        Z = [0.0] * num_ctf  # Interior temp response
+        F = [0.0] * num_ctf  # Flux history
+        T_prev = np.zeros(total_nodes)  # Previous temperatures
+
+        # Impulse response for exterior temperature (X, Y)
+        for t in range(num_ctf):
+            b_out = b.copy()
+            if t == 0:
+                b_out[0] = dt / (rho[0] * c[0] * dx[0] * R_out)  # Unit outdoor temp impulse
+            T = sparse_linalg.spsolve(A, b_out + T_prev)
+            q_in = (T[-1] - 0.0) / R_in  # Indoor heat flux (W/m²)
+            Y[t] = q_in
+            q_out = (0.0 - T[0]) / R_out  # Outdoor heat flux
+            X[t] = q_out
+            T_prev = T.copy()
+
+        # Reset for interior temperature (Z)
+        T_prev = np.zeros(total_nodes)
+        for t in range(num_ctf):
+            b_in = b.copy()
+            if t == 0:
+                b_in[-1] = dt / (rho[-1] * c[-1] * dx[-1] * R_in)  # Unit indoor temp impulse
+            T = sparse_linalg.spsolve(A, b_in + T_prev)
+            q_in = (T[-1] - 0.0) / R_in
+            Z[t] = q_in
+            T_prev = T.copy()
+
+        # Flux history coefficients (F)
+        T_prev = np.zeros(total_nodes)
+        for t in range(num_ctf):
+            b_flux = np.zeros(total_nodes)
+            if t == 0:
+                b_flux[-1] = -1.0 / (rho[-1] * c[-1] * dx[-1])  # Unit flux impulse
+            T = sparse_linalg.spsolve(A, b_flux + T_prev)
+            q_in = (T[-1] - 0.0) / R_in
+            F[t] = q_in
+            T_prev = T.copy()
+
+        ctf = CTFCoefficients(X=X, Y=Y, Z=Z, F=F)
+        with cls._cache_lock:
+            cls._ctf_cache[construction_hash] = ctf
+        logger.info(f"Calculated CTF coefficients for construction {construction.name}")
+        return ctf
+
+    @classmethod
+    def calculate_ctf_tables(cls, component) -> CTFCoefficients:
+        """Placeholder for future implementation of CTF table lookups for windows, doors, and skylights.
+
+        Args:
+            component: Building component with construction properties.
+
+        Returns:
+            CTFCoefficients: Placeholder zero coefficients until implementation.
+        """
+        logger.info(f"CTF table calculation for {component.component_type.value} component '{component.name}' not yet implemented. Returning zero coefficients.")
+        return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])

utils/solar.py

@@ -0,0 +1,480 @@
+import numpy as np
+from typing import List, Dict, Any, Optional, Tuple
+import math
+from datetime import datetime
+from data.material_library import MaterialLibrary, Construction, GlazingMaterial, DoorMaterial, Material
+from utils.ctf_calculations import ComponentType
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class SolarCalculations:
+    """Class for performing ASHRAE-compliant solar radiation and angle calculations.
+
+    References:
+    - ASHRAE Handbook—Fundamentals, Chapter 18 (Sol-air temperature)
+    - ASHRAE Handbook—Fundamentals, Chapter 15 (Dynamic SHGC)
+    """
+
+    # Updated dynamic SHGC coefficients (provided by user, May 2025)
+    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]
+    }
+
+    # Mapping of GlazingMaterial names to SHGC types
+    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"
+    }
+
+    def __init__(self, material_library: MaterialLibrary, project_materials: Optional[Dict] = None,
+                 project_constructions: Optional[Dict] = None, project_glazing_materials: Optional[Dict] = None,
+                 project_door_materials: Optional[Dict] = None):
+        """
+        Initialize SolarCalculations with material library and optional project-specific libraries.
+        
+        Args:
+            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.
+        """
+        self.material_library = material_library
+        self.project_materials = project_materials or {}
+        self.project_constructions = project_constructions or {}
+        self.project_glazing_materials = project_glazing_materials or {}
+        self.project_door_materials = project_door_materials or {}
+        logger.info("Initialized SolarCalculations with MaterialLibrary and project-specific libraries.")
+
+    @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
+
+    def get_surface_parameters(self, component: Any, building_info: 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.
+
+        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 = (self.project_constructions.get(construction.name) or
+                                        self.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 = (self.project_door_materials.get(door_material.name) or
+                                         self.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 = (self.project_glazing_materials.get(glazing_material.name) or
+                                            self.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_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 SolarCalculations.SHGC_COEFFICIENTS:
+            logger.warning(f"Unknown glazing type '{glazing_type}'. Using default SHGC coefficients for Single Clear.")
+            glazing_type = "Single Clear"
+        
+        c = SolarCalculations.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
+
+    def calculate_solar_parameters(
+        self,
+        hourly_data: List[Dict[str, Any]],
+        latitude: float,
+        longitude: float,
+        timezone: float,
+        ground_reflectivity: float,
+        components: Dict[str, List[Any]]
+    ) -> List[Dict[str, Any]]:
+        """Calculate solar angles, sol-air temperature, and solar heat gain for hourly data with GHI > 0.
+
+        Args:
+            hourly_data (List[Dict]): Hourly weather data containing month, day, hour, GHI, DNI, DHI, dry_bulb.
+            latitude (float): Latitude in degrees.
+            longitude (float): Longitude in degrees.
+            timezone (float): Timezone offset in hours.
+            ground_reflectivity (float): Ground reflectivity (albedo, typically 0.2).
+            components (Dict[str, List]): Dictionary of component lists (e.g., walls, windows) with id, area,
+                                         component_type, facade, construction, glazing_material, or door_material.
+
+        Returns:
+            List[Dict]: List of results for each hour with GHI > 0, containing solar angles and per-component results.
+
+        Raises:
+            ValueError: If required weather data or component parameters are missing or invalid.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapters 18 and 15.
+        """
+        year = 2025  # Fixed year since not provided in data
+        results = []
+
+        # 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
+
+        logger.info(f"Using parameters: latitude={latitude}, longitude={longitude}, timezone={timezone}, "
+                   f"ground_reflectivity={ground_reflectivity}")
+
+        lambda_std = 15 * timezone  # Standard meridian longitude (°)
+
+        # Cache facade azimuths (used only for walls, doors, windows)
+        building_info = components.get("_building_info", {})
+        facade_cache = {
+            "A": building_info.get("orientation_angle", 0.0),
+            "B": (building_info.get("orientation_angle", 0.0) + 90.0) % 360,
+            "C": (building_info.get("orientation_angle", 0.0) + 180.0) % 360,
+            "D": (building_info.get("orientation_angle", 0.0) + 270.0) % 360
+        }
+
+        for record in hourly_data:
+            # Step 1: Extract and validate data
+            month = record.get("month")
+            day = record.get("day")
+            hour = record.get("hour")
+            ghi = record.get("global_horizontal_radiation", 0)
+            dni = record.get("direct_normal_radiation", ghi * 0.7)  # Fallback: estimate DNI
+            dhi = record.get("diffuse_horizontal_radiation", ghi * 0.3)  # Fallback: estimate DHI
+            outdoor_temp = record.get("dry_bulb")
+            
+            if None in [month, day, hour, outdoor_temp]:
+                logger.error(f"Missing required weather data for {month}/{day}/{hour}")
+                raise ValueError(f"Missing required weather data for {month}/{day}/{hour}")
+
+            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}")
+
+            if ghi <= 0:
+                logger.info(f"Skipping hour {month}/{day}/{hour} due to GHI={ghi} <= 0")
+                continue  # Skip hours with no solar radiation
+
+            logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
+                       f"dry_bulb={outdoor_temp}")
+
+            # Step 2: Local Solar Time (LST) with Equation of Time
+            n = self.day_of_year(month, day, year)
+            EOT = self.equation_of_time(n)
+            standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
+            LST = standard_time + (4 * (lambda_std - longitude) + EOT) / 60 
+
+            # Step 3: Solar Declination (δ)
+            delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
+
+            # Step 4: Hour Angle (HRA)
+            hra = 15 * (LST - 12)
+
+            # Step 5: 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 6: Component-specific calculations
+            component_results = []
+            for comp_type, comp_list in components.items():
+                if comp_type == "_building_info":
+                    continue
+                for comp in comp_list:
+                    try:
+                        # Get surface parameters
+                        surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption = \
+                            self.get_surface_parameters(comp, building_info)
+                        
+                        # For windows/skylights, get SHGC from material
+                        shgc = 0.7  # Default
+                        if comp.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                            glazing_material = getattr(comp, 'glazing_material', None)
+                            if glazing_material:
+                                glazing_material_obj = (self.project_glazing_materials.get(glazing_material.name) or
+                                    self.material_library.library_glazing_materials.get(glazing_material.name))
+                                if glazing_material_obj:
+                                    shgc = glazing_material_obj.shgc
+                                else:
+                                    logger.warning(f"Glazing material '{glazing_material.name}' not found for {comp.id}. Using default SHGC=0.7.")
+
+                        # 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(comp, 'id', 'unknown_component')} at {month}/{day}/{hour}: "
+                            f"surface_tilt={surface_tilt:.2f}, surface_tazimuth={surface_sazimuth:.2f}, "
+                            f"cos_theta={cos_theta:.2f}")
+
+                        # 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
+
+                        # Initialize result
+                        comp_result = {
+                            "component_id": getattr(comp, 'id', 'unknown_component'),
+                            "total_incident_radiation": round(I_t, 2),
+                            "solar_absorption": round(solar_absorption, 2),
+                            "emissivity": round(emissivity, 2) if emissivity is not None else None
+                        }
+
+                        # Calculate sol-air temperature for opaque surfaces
+                        if comp.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                            delta_R = 63.0 if comp.component_type == ComponentType.ROOF else 0.0
+                            sol_air_temp = outdoor_temp + (solar_absorption * I_t - (emissivity or 0.9) * 
+                            delta_R) / h_o
+                            comp_result["sol_air_temp"] = round(sol_air_temp, 2)
+                            logger.info(f"Sol-air temp for {comp_result['component_id']} at {month}/{day}/{hour}: {sol_air_temp:.2f}°C")
+
+                        # Calculate solar heat gain for fenestration
+                        elif comp.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                            glazing_type = self.GLAZING_TYPE_MAPPING.get(comp.name, 'Single Clear')
+                            iac = getattr(comp, 'iac', 1.0)  # Default internal shading
+                            shgc_dynamic = shgc * self.calculate_dynamic_shgc(glazing_type, cos_theta)
+                            solar_heat_gain = comp.area * shgc_dynamic * I_t * iac / 1000  # kW
+                            comp_result["solar_heat_gain"] = round(solar_heat_gain, 2)
+                            comp_result["shgc_dynamic"] = round(shgc_dynamic, 2)
+                            logger.info(f"Solar heat gain for {comp_result['component_id']} at {month}/{day}/{hour}: "
+                                        f"{solar_heat_gain:.2f} kW (area={comp.area}, shgc_dynamic={shgc_dynamic:.2f}, "
+                                        f"I_t={I_t:.2f}, iac={iac})")
+                        
+                        component_results.append(comp_result)
+
+                    except Exception as e:
+                        component_id = getattr(comp, 'id', 'unknown_component')
+                        logger.error(f"Error processing component {component_id} at {month}/{day}/{hour}: {str(e)}")
+                        continue
+
+            # Store results for this hour
+            result = {
+                "month": month,
+                "day": day,
+                "hour": hour,
+                "declination": round(delta, 2),
+                "LST": round(LST, 2),
+                "HRA": round(hra, 2),
+                "altitude": round(alpha, 2),
+                "azimuth": round(azimuth, 2),
+                "component_results": component_results
+            }
+            results.append(result)
+
+        return results