energy-simulation

name	energy-simulation
description	Building energy simulation and analysis for construction. Calculate heating/cooling loads, evaluate envelope performance, optimize HVAC sizing, and ensure energy code compliance.

Energy Simulation

Overview

This skill implements building energy simulation and analysis. Calculate thermal loads, evaluate building envelope performance, and optimize systems for energy efficiency and code compliance.

Capabilities:

• Heating/cooling load calculations
• Envelope thermal analysis
• HVAC system sizing
• Energy code compliance
• Renewable energy integration
• Life cycle cost analysis

Quick Start

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from enum import Enum
import numpy as np

class WallType(Enum):
    CONCRETE = "concrete"
    BRICK = "brick"
    WOOD_FRAME = "wood_frame"
    STEEL_FRAME = "steel_frame"
    CURTAIN_WALL = "curtain_wall"

@dataclass
class BuildingEnvelope:
    wall_area_m2: float
    wall_u_value: float  # W/m²K
    roof_area_m2: float
    roof_u_value: float
    floor_area_m2: float
    floor_u_value: float
    window_area_m2: float
    window_u_value: float
    window_shgc: float  # Solar Heat Gain Coefficient

@dataclass
class ClimateData:
    location: str
    heating_degree_days: float  # HDD base 18°C
    cooling_degree_days: float  # CDD base 18°C
    design_temp_winter: float
    design_temp_summer: float

def calculate_heat_loss(envelope: BuildingEnvelope, climate: ClimateData,
                       indoor_temp: float = 21) -> float:
    """Calculate design heat loss (W)"""
    delta_t = indoor_temp - climate.design_temp_winter

    # Transmission losses
    wall_loss = envelope.wall_area_m2 * envelope.wall_u_value * delta_t
    roof_loss = envelope.roof_area_m2 * envelope.roof_u_value * delta_t
    floor_loss = envelope.floor_area_m2 * envelope.floor_u_value * delta_t * 0.5  # Ground factor
    window_loss = envelope.window_area_m2 * envelope.window_u_value * delta_t

    total_loss = wall_loss + roof_loss + floor_loss + window_loss

    # Add infiltration estimate (simplified)
    volume = envelope.floor_area_m2 * 3  # Assume 3m height
    infiltration = volume * 0.5 * 0.33 * delta_t  # 0.5 ACH, 0.33 Wh/m³K

    return total_loss + infiltration

# Example
envelope = BuildingEnvelope(
    wall_area_m2=500, wall_u_value=0.35,
    roof_area_m2=200, roof_u_value=0.25,
    floor_area_m2=200, floor_u_value=0.30,
    window_area_m2=100, window_u_value=1.4, window_shgc=0.4
)

climate = ClimateData(
    location="Moscow",
    heating_degree_days=5000,
    cooling_degree_days=300,
    design_temp_winter=-25,
    design_temp_summer=30
)

heat_loss = calculate_heat_loss(envelope, climate)
print(f"Design heat loss: {heat_loss/1000:.1f} kW")

Comprehensive Energy Analysis

Building Thermal Model

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from enum import Enum
import numpy as np
from datetime import datetime

@dataclass
class MaterialLayer:
    name: str
    thickness_m: float
    conductivity: float  # W/mK
    density: float  # kg/m³
    specific_heat: float  # J/kgK

    @property
    def resistance(self) -> float:
        """Thermal resistance R (m²K/W)"""
        return self.thickness_m / self.conductivity if self.conductivity > 0 else 0

@dataclass
class WallAssembly:
    name: str
    layers: List[MaterialLayer]
    inside_surface_resistance: float = 0.13  # m²K/W
    outside_surface_resistance: float = 0.04

    @property
    def () -> :
         (.inside_surface_resistance +
                (layer.resistance  layer  .layers) +
                .outside_surface_resistance)


     () -> :
          / .total_resistance  .total_resistance >   


 :
    name: 
    u_value: 
    shgc: 
    visible_transmittance:  = 
    frame_fraction:  = 


 :
    zone_id: 
    name: 
    floor_area_m2: 
    volume_m3: 
    occupancy: 
    lighting_power_density:   
    equipment_power_density:   
    ventilation_rate:   
    setpoint_heating:  = 
    setpoint_cooling:  = 


 :
    zones: [Zone]
    walls: []  
    windows: []  
    roofs: []  
    floors: []  

 :
    

    
    CLIMATE_DB = {
        : {
            : , : ,
            : -, : ,
            : 
        },
        : {
            : , : ,
            : -, : ,
            : 
        },
        : {
            : , : ,
            : , : ,
            : 
        }
    }

     ():
        .building = building
        .location = location.lower()
        .climate = .CLIMATE_DB.get(.location, .CLIMATE_DB[])

     () -> :
        
        delta_t =  - .climate[]
        results = {}

         zone  .building.zones:
            
            wall_loss = 
            window_loss = 
            roof_loss = 
            floor_loss = 

             wall  .building.walls:
                 wall[] == zone.zone_id:
                    u_value = wall[].u_value
                    wall_loss += wall[] * u_value * delta_t

             window  .building.windows:
                 window[] == zone.zone_id:
                    window_loss += window[] * window[].u_value * delta_t

             roof  .building.roofs:
                 roof[] == zone.zone_id:
                    u_value = roof[].u_value
                    roof_loss += roof[] * u_value * delta_t

             floor  .building.floors:
                 floor[] == zone.zone_id:
                    u_value = floor[].u_value
                    factor =   floor.get(, )  
                    floor_loss += floor[] * u_value * delta_t * factor

            
            infiltration_loss = zone.volume_m3 *  *  * delta_t

            
            ventilation_loss = zone.occupancy * zone.ventilation_rate *  * delta_t

            total = wall_loss + window_loss + roof_loss + floor_loss + infiltration_loss + ventilation_loss

            results[zone.zone_id] = {
                : zone.name,
                : wall_loss,
                : window_loss,
                : roof_loss,
                : floor_loss,
                : infiltration_loss,
                : ventilation_loss,
                : total,
                : total / ,
                : total / zone.floor_area_m2
            }

         results

     () -> :
        
        delta_t = .climate[] - 
        results = {}

         zone  .building.zones:
            
            transmission_gain = 
             wall  .building.walls:
                 wall[] == zone.zone_id:
                    u_value = wall[].u_value
                    
                    sol_air_delta = delta_t + ._get_sol_air_correction(wall[])
                    transmission_gain += wall[] * u_value * sol_air_delta

            
            solar_gain = 
             window  .building.windows:
                 window[] == zone.zone_id:
                    shgc = window[].shgc
                    irradiance = ._get_solar_irradiance(window[])
                    solar_gain += window[] * shgc * irradiance

            
            window_conduction = 
             window  .building.windows:
                 window[] == zone.zone_id:
                    window_conduction += window[] * window[].u_value * delta_t

            
            lighting_gain = zone.floor_area_m2 * zone.lighting_power_density
            equipment_gain = zone.floor_area_m2 * zone.equipment_power_density
            people_gain = zone.occupancy *   

            
            ventilation_gain = zone.occupancy * zone.ventilation_rate *  * delta_t

            total = (transmission_gain + solar_gain + window_conduction +
                    lighting_gain + equipment_gain + people_gain + ventilation_gain)

            results[zone.zone_id] = {
                : zone.name,
                : transmission_gain,
                : solar_gain,
                : window_conduction,
                : lighting_gain,
                : equipment_gain,
                : people_gain,
                : ventilation_gain,
                : total,
                : total / ,
                : total / zone.floor_area_m2
            }

         results

     () -> :
        
        corrections = {
            : , : , : , : ,
            : , : , : , : 
        }
         corrections.get(orientation.lower(), )

     () -> :
        
        
        irradiance = {
            : , : , : , : ,
            : , : , : , : 
        }
         irradiance.get(orientation.lower(), )

HVAC System Sizing

class HVACSizer:
    """Size HVAC systems based on loads"""

    def __init__(self, calculator: ThermalCalculator):
        self.calculator = calculator

    def size_heating_system(self, safety_factor: float = 1.15) -> Dict:
        """Size heating system"""
        heating_loads = self.calculator.calculate_design_heating_load()

        total_load = sum(z['total_kw'] for z in heating_loads.values())
        sized_capacity = total_load * safety_factor

        # Recommend system type
        if sized_capacity < 15:
            system_type = "Split system heat pump"
        elif sized_capacity < 50:
            system_type = "Packaged rooftop unit"
        elif sized_capacity < 200:
            system_type = "Central boiler with radiators"
        else:
            system_type = "Central plant with multiple boilers"

        return {
            'total_load_kw': total_load,
            'sized_capacity_kw': sized_capacity,
            'safety_factor': safety_factor,
            'recommended_system': system_type,
            'zone_loads': heating_loads
        }

    def size_cooling_system(self, safety_factor: float = 1.1) -> :
        
        cooling_loads = .calculator.calculate_design_cooling_load()

        total_load = (z[]  z  cooling_loads.values())
        sized_capacity = total_load * safety_factor

        
        capacity_tons = sized_capacity / 

        
         capacity_tons < :
            system_type = 
         capacity_tons < :
            system_type = 
         capacity_tons < :
            system_type = 
        :
            system_type = 

         {
            : total_load,
            : capacity_tons,
            : sized_capacity,
            : capacity_tons * safety_factor,
            : safety_factor,
            : system_type,
            : cooling_loads
        }

     () -> :
        
        climate = .calculator.climate

        heating_loads = .calculator.calculate_design_heating_load()
        cooling_loads = .calculator.calculate_design_cooling_load()

        total_heating_load = (z[]  z  heating_loads.values())
        total_cooling_load = (z[]  z  cooling_loads.values())

        
        
        delta_t_heating =  - climate[]
        heating_kwh = total_heating_load * climate[] *  / delta_t_heating / 

        delta_t_cooling = climate[] - 
        cooling_kwh = total_cooling_load * climate[] *  / delta_t_cooling /   delta_t_cooling >   

        
        heating_fuel_efficiency =   
        cooling_cop =   

        heating_consumption = heating_kwh / heating_fuel_efficiency
        cooling_consumption = cooling_kwh / cooling_cop

         {
            : total_heating_load,
            : total_cooling_load,
            : heating_kwh,
            : cooling_kwh,
            : heating_consumption,
            : cooling_consumption,
            : heating_consumption + cooling_consumption
        }

Energy Code Compliance

@dataclass
class EnergyCodeRequirements:
    code_name: str
    climate_zone: str
    wall_u_max: float
    roof_u_max: float
    floor_u_max: float
    window_u_max: float
    window_shgc_max: float
    lighting_lpd_max: float  # W/m²

class ComplianceChecker:
    """Check energy code compliance"""

    CODES = {
        'ASHRAE_90.1_2019_4A': EnergyCodeRequirements(
            code_name="ASHRAE 90.1-2019",
            climate_zone="4A",
            wall_u_max=0.45,
            roof_u_max=0.27,
            floor_u_max=0.32,
            window_u_max=2.0,
            window_shgc_max=0.40,
            lighting_lpd_max=9.0
        ),
        'IECC_2021_5A': EnergyCodeRequirements(
            code_name="IECC 2021",
            climate_zone="5A",
            wall_u_max=0.35,
            roof_u_max=0.20,
            floor_u_max=0.30,
            window_u_max=1.7,
            window_shgc_max=0.40,
            lighting_lpd_max=8.5
        )
    }

    def __init__(self, code_key: str):
        self.requirements = self.CODES.get(code_key)
        if not self.requirements:
            raise ValueError()

     () -> :
        
        results = {
            : .requirements.code_name,
            : .requirements.climate_zone,
            : ,
            : []
        }

        
         wall  building.walls:
            u_value = wall[].u_value
             u_value > .requirements.wall_u_max:
                results[] = 
                results[].append({
                    : ,
                    : u_value,
                    : .requirements.wall_u_max,
                    : 
                })

        
         window  building.windows:
            u_value = window[].u_value
            shgc = window[].shgc

             u_value > .requirements.window_u_max:
                results[] = 
                results[].append({
                    : ,
                    : u_value,
                    : .requirements.window_u_max,
                    : 
                })

             shgc > .requirements.window_shgc_max:
                results[] = 
                results[].append({
                    : ,
                    : shgc,
                    : .requirements.window_shgc_max,
                    : 
                })

        
         roof  building.roofs:
            u_value = roof[].u_value
             u_value > .requirements.roof_u_max:
                results[] = 
                results[].append({
                    : ,
                    : u_value,
                    : .requirements.roof_u_max,
                    : 
                })

         results

     () -> :
        
        results = {
            : ,
            : []
        }

         zone  zones:
             zone.lighting_power_density > .requirements.lighting_lpd_max:
                results[] = 
                results[].append({
                    : zone.name,
                    : zone.lighting_power_density,
                    : .requirements.lighting_lpd_max
                })

         results

Quick Reference

Component	Good U-Value	Code Maximum
Wall	< 0.25 W/m²K	0.35-0.45
Roof	< 0.15 W/m²K	0.20-0.27
Floor	< 0.20 W/m²K	0.25-0.32
Window	< 1.2 W/m²K	1.7-2.0

Resources

• ASHRAE 90.1: Energy standard for buildings
• IECC: International Energy Conservation Code
• EnergyPlus: DOE building simulation
• DDC Website: https://datadrivenconstruction.io

Next Steps

• See co2-estimation for carbon analysis
• See cost-prediction for energy cost modeling
• See bim-validation-pipeline for model integration