SkillAgentSearch skills...

energy-simulation

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

Install / Use

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill energy-simulation

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

91/100

Category

Marketing

Supported Platforms

Universal

Our assessment of energy-simulation

energy-simulation scores 91/100 on our quality scale, 234th of 649 Marketing skills we index (top 37%).

Its SKILL.md is 19 KB long, well organised into 11 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

It has 333 GitHub stars, a meaningful sign that others use it.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
11/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 3 months ago, so energy-simulation is actively maintained.
  • Our last check on 2026-11-20 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

energy-simulation compared with similar skills

All 4 of these similar skills score higher than energy-simulation; compare them before choosing.

SkillScoreStarsUpdatedFormat
energy-simulation (this skill)by datadrivenconstruction913333mo agoSKILL.md
Agent-Reachby Panniantong100113.3k12d agoCLAUDE.md
headroomby headroomlabs-ai10080.2ktodayCLAUDE.md
Scraplingby D4Vinci100104.4k2d agoMCP Server
crawl4aiby unclecode10087.6ktodayMCP Server

Frequently asked questions

How do I install energy-simulation?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill energy-simulation. The install tabs above show the steps for each supported agent.
Which AI agents does energy-simulation work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is energy-simulation safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is energy-simulation still maintained?
The repository was last updated about 3 months ago, so energy-simulation is actively maintained.

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." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "🚀", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}

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 total_resistance(self) -> float:
        return (self.inside_surface_resistance +
                sum(layer.resistance for layer in self.layers) +
                self.outside_surface_resistance)

    @property
    def u_value(self) -> float:
        return 1 / self.total_resistance if self.total_resistance > 0 else 0

@dataclass
class Window:
    name: str
    u_value: float
    shgc: float
    visible_transmittance: float = 0.6
    frame_fraction: float = 0.2

@dataclass
class Zone:
    zone_id: str
    name: str
    floor_area_m2: float
    volume_m3: float
    occupancy: int
    lighting_power_density: float  # W/m²
    equipment_power_density: float  # W/m²
    ventilation_rate: float  # L/s per person
    setpoint_heating: float = 21
    setpoint_cooling: float = 24

@dataclass
class BuildingGeometry:
    zones: List[Zone]
    walls: List[Dict]  # {zone, orientation, area, assembly}
    windows: List[Dict]  # {zone, orientation, area, window_type}
    roofs: List[Dict]  # {zone, area, assembly}
    floors: List[Dict]  # {zone, area, assembly, is_ground}

class ThermalCalculator:
    """Calculate building thermal loads"""

    # Standard climate data (simplified)
    CLIMATE_DB = {
        'moscow': {
            'hdd': 5000, 'cdd': 300,
            'design_winter': -25, 'design_summer': 30,
            'latitude': 55.75
        },
        'new_york': {
            'hdd': 2500, 'cdd': 800,
            'design_winter': -12, 'design_summer': 33,
            'latitude': 40.71
        },
        'dubai': {
            'hdd': 50, 'cdd': 3000,
            'design_winter': 15, 'design_summer': 45,
            'latitude': 25.20
        }
    }

    def __init__(self, building: BuildingGeometry, location: str):
        self.building = building
        self.location = location.lower()
        self.climate = self.CLIMATE_DB.get(self.location, self.CLIMATE_DB['moscow'])

    def calculate_design_heating_load(self) -> Dict:
        """Calculate design heating load for each zone"""
        delta_t = 21 - self.climate['design_winter']
        results = {}

        for zone in self.building.zones:
            # Transmission losses
            wall_loss = 0
            window_loss = 0
            roof_loss = 0
            floor_loss = 0

            for wall in self.building.walls:
                if wall['zone'] == zone.zone_id:
                    u_value = wall['assembly'].u_value
                    wall_loss += wall['area'] * u_value * delta_t

            for window in self.building.windows:
                if window['zone'] == zone.zone_id:
                    window_loss += window['area'] * window['window_type'].u_value * delta_t

            for roof in self.building.roofs:
                if roof['zone'] == zone.zone_id:
                    u_value = roof['assembly'].u_value
                    roof_loss += roof['area'] * u_value * delta_t

            for floor in self.building.floors:
                if floor['zone'] == zone.zone_id:
                    u_value = floor['assembly'].u_value
                    factor = 0.5 if floor.get('is_ground', False) else 1.0
                    floor_loss += floor['area'] * u_value * delta_t * factor

            # Infiltration
            infiltration_loss = zone.volume_m3 * 0.5 * 0.33 * delta_t

            # Ventilation (if mechanical)
            ventilation_loss = zone.occupancy * zone.ventilation_rate * 1.2 * delta_t

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

            results[zone.zone_id] = {
                'zone_name': zone.name,
                'wall_loss_w': wall_loss,
                'window_loss_w': window_loss,
                'roof_loss_w': roof_loss,
                'floor_loss_w': floor_loss,
                'infiltration_w': infiltration_loss,
                'ventilation_w': ventilation_loss,
                'total_w': total,
                'total_kw': total / 1000,
                'w_per_m2': total / zone.floor_area_m2
            }

        return results

    def calculate_design_cooling_load(self) -> Dict:
        """Calculate design cooling load for each zone"""
        delta_t = self.climate['design_summer'] - 24
        results = {}

        for zone in self.building.zones:
            # Transmission gains
            transmission_gain = 0
            for wall in self.building.walls:
                if wall['zone'] == zone.zone_id:
                    u_value = wall['assembly'].u_value
                    # Apply sol-air temperature correction for orientation
                    sol_air_delta = delta_t + self._get_sol_air_correction(wall['orientation'])
                    transmission_gain += wall['area'] * u_value * sol_air_delta

            # Window solar gains
            solar_gain = 0
            for window in self.building.windows:
                if window['zone'] == zone.zone_id:
                    shgc = window['window_type'].shgc
                    irradiance = self._get_solar_irradiance(window['orientation'])
                    solar_gain += window['area'] * shgc * irradiance

            # Window conduction
            window_conduction = 0
            for window in self.building.windows:
                if window['zone'] == zone.zone_id:
                    window_conduction += window['area'] * window['window_type'].u_value * delta_t

            # Internal gains
            lighting_gain = zone.floor_area_m2 * zone.lighting_power_density
            equipment_gain = zone.floor_area_m2 * zone.equipment_power_density
            people_gain = zone.occupancy * 75  # W per person sensible

            # Ventilation
            ventilation_gain = zone.occupancy * zone.ventilation_rate * 1.2 * delta_t

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

            results[zone.zone_id] = {
                'zone_name': zone.name,
                'transmission_gain_w': transmission_gain,
                'solar_gain_w': solar_gain,
                'window_conduction_w': window_conduction,
                'lighting_gain_w': lighting_gain,
                'equipment_gain_w': equipment_gain,
                'people_gain_w': people_gain,
                'ventilation_gain_w': ventilation_gain,
                'total_w': total,
                'total_kw': total / 1000,
                'w_per_m2': total / zone.floor_area_m2
            }

        return results

    def _get_sol_air_correction(self, orientation: str) -> float:
        """Get sol-air temperature correction by orientation"""
        corrections = {
            'north': 0, 'south': 8, 'east': 4, 'west': 6,
            'northeast': 2, 'northwest': 3, 'southeast': 6, 'southwest': 7
        }
        return corrections.get(orientation.lower(), 3)

    def _get_solar_irradiance(self, orientation: str) -> float:
        """Get design solar irradiance W/m² by orientation"""
        # Simplified peak values
        irradiance = {
            'north': 150, 'south': 450, 'east': 350, 'west': 350,
            'northeast': 200, 'northwest': 200, 'southeast': 400, 'southwest': 400
        }
        return irradiance.get(orientation.lower(), 300)

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_loa

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars333
CategoryMarketing
Updated2mo ago
Forks82

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions
energy-simulation — Universal Skill: Install & Safety Check | SkillAgent