hvacpy 0.4.0__tar.gz

hvacpy-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hvacpy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hvacpy-0.4.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: hvacpy
+Version: 0.4.0
+Summary: HVAC and building energy calculations for engineers
+Author: hvacpy contributors
+License: MIT
+Project-URL: Homepage, https://github.com/anirudhsankar/hvacpy
+Project-URL: Repository, https://github.com/anirudhsankar/hvacpy
+Project-URL: Issues, https://github.com/anirudhsankar/hvacpy/issues
+Project-URL: Changelog, https://github.com/anirudhsankar/hvacpy/blob/main/CHANGELOG.md
+Keywords: hvac,building-energy,engineering,ashrae,u-value,heat-load,psychrometrics,cooling-load,equipment-sizing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pint>=0.23
+Requires-Dist: psychrolib>=2.5.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# hvacpy
+
+**HVAC and building energy calculations for engineers.**
+
+Free, open, practitioner-first Python tooling that replaces expensive
+proprietary software and inherited Excel spreadsheets for everyday
+HVAC engineering calculations.
+
+[![PyPI](https://img.shields.io/pypi/v/hvacpy)](https://pypi.org/project/hvacpy/)
+[![Python](https://img.shields.io/pypi/pyversions/hvacpy)](https://pypi.org/project/hvacpy/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+## Installation
+```bash
+pip install hvacpy
+```
+
+## What It Does
+
+| Module | What you can calculate |
+|--------|----------------------|
+| **Assembly** | U-values and R-values for any wall, roof, or floor construction |
+| **Psychrometrics** | All moist air properties from any two known conditions |
+| **Heat Loads** | Cooling and heating loads for rooms and zones (CLTD/CLF method) |
+| **Equipment Sizing** | Split systems, RTUs, FCUs, chillers, heat pumps, duct sizing, ventilation |
+
+## Quick Examples
+
+**Wall U-value:**
+```python
+from hvacpy import Q_, Assembly
+
+wall = Assembly("Brick Cavity Wall")
+wall.add_layer("brick_common",      Q_(110, "mm"))
+wall.add_layer("mineral_wool_batt", Q_(75, "mm"))
+wall.add_layer("plasterboard_std",  Q_(12.5, "mm"))
+
+print(wall.u_value)    # 0.347 W/(m²·K)
+```
+
+**Moist air properties:**
+```python
+from hvacpy import Q_, AirState
+
+air = AirState(dry_bulb=Q_(25, "degC"), rh=0.60)
+print(air.wet_bulb)    # 19.47 °C
+print(air.dew_point)   # 16.70 °C
+print(air.enthalpy)    # 55.45 kJ/kg
+```
+
+**Cooling load:**
+```python
+from hvacpy import (
+    Q_, Room, WallComponent, InternalGain, CoolingLoad, Orientation
+)
+
+room = Room(name="Office", floor_area=Q_(50, "m**2"),
+            ceiling_height=Q_(3, "m"))
+room.walls.append(WallComponent(
+    name="South Wall", assembly=wall,
+    area=Q_(20, "m**2"), orientation=Orientation.S,
+))
+room.internal_gains.append(
+    InternalGain(gain_type="people", count=8, activity="office_work")
+)
+
+load = CoolingLoad(room, city="london")
+print(f"Peak cooling: {load.peak_total.to('kW'):.2f}")
+print(load.breakdown())
+```
+
+**Equipment sizing (v0.4):**
+```python
+from hvacpy import Q_, SplitSystem, DuctSizer, VentilationCheck
+
+# Size a split system from the cooling load
+ss = SplitSystem(load, cop_rated=3.5)
+print(ss.summary())           # box-format sizing report
+print(ss.nominal_capacity)    # e.g. 10.0 kW
+print(ss.oversizing_warning)  # None / 'WARNING' / 'CRITICAL'
+
+# Size a main supply duct — equal friction method
+ds = DuctSizer(Q_(0.5, "m**3/s"), method="equal_friction")
+print(ds.diameter)            # e.g. 400 mm standard size
+print(ds.velocity)            # actual air velocity
+print(ds.summary())           # Dia400mm - 3.98m/s - 0.45Pa/m - or 600x400mm rect
+
+# Check ventilation compliance (ASHRAE 62.1-2022)
+vc = VentilationCheck(room, supply_airflow=Q_(0.5, "m**3/s"), space_type="office")
+print(vc.compliant)           # True / False
+print(vc.summary())
+```
+
+## Design Principles
+
+- **Correct before fast** — all equations trace to ASHRAE and ISO sources
+- **Units everywhere** — every value carries its unit, no silent conversions
+- **Practitioner language** — APIs use terms engineers actually use
+- **The engineer always decides** — hvacpy calculates and warns; it never refuses
+
+## Standards Referenced
+
+| Standard | Used in |
+|---|---|
+| ASHRAE HOF 2021 Ch.28 | Cooling loads (CLTD/CLF) |
+| ASHRAE HOF 2021 Ch.18 | Heating loads |
+| ASHRAE HOF 2021 Ch.14 | Psychrometrics |
+| ASHRAE HOF 2021 Ch.21 | Duct sizing |
+| ASHRAE HSE 2020 | Equipment sizing |
+| ASHRAE 62.1-2022 | Ventilation compliance |
+
+## Test Coverage
+
+185 tests · 92% equipment coverage · all verified against reference values
+
+## Roadmap
+
+- v0.5 — Weather data (EPW files, degree days, ASHRAE design conditions)
+- v0.6 — Data centre loads (IT load, PUE, WUE, economiser analysis)
+- v1.0 — Annual energy estimation and carbon footprint reporting
+
+## License
+
+MIT

hvacpy-0.4.0/README.md

@@ -0,0 +1,124 @@
+# hvacpy
+
+**HVAC and building energy calculations for engineers.**
+
+Free, open, practitioner-first Python tooling that replaces expensive
+proprietary software and inherited Excel spreadsheets for everyday
+HVAC engineering calculations.
+
+[![PyPI](https://img.shields.io/pypi/v/hvacpy)](https://pypi.org/project/hvacpy/)
+[![Python](https://img.shields.io/pypi/pyversions/hvacpy)](https://pypi.org/project/hvacpy/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+## Installation
+```bash
+pip install hvacpy
+```
+
+## What It Does
+
+| Module | What you can calculate |
+|--------|----------------------|
+| **Assembly** | U-values and R-values for any wall, roof, or floor construction |
+| **Psychrometrics** | All moist air properties from any two known conditions |
+| **Heat Loads** | Cooling and heating loads for rooms and zones (CLTD/CLF method) |
+| **Equipment Sizing** | Split systems, RTUs, FCUs, chillers, heat pumps, duct sizing, ventilation |
+
+## Quick Examples
+
+**Wall U-value:**
+```python
+from hvacpy import Q_, Assembly
+
+wall = Assembly("Brick Cavity Wall")
+wall.add_layer("brick_common",      Q_(110, "mm"))
+wall.add_layer("mineral_wool_batt", Q_(75, "mm"))
+wall.add_layer("plasterboard_std",  Q_(12.5, "mm"))
+
+print(wall.u_value)    # 0.347 W/(m²·K)
+```
+
+**Moist air properties:**
+```python
+from hvacpy import Q_, AirState
+
+air = AirState(dry_bulb=Q_(25, "degC"), rh=0.60)
+print(air.wet_bulb)    # 19.47 °C
+print(air.dew_point)   # 16.70 °C
+print(air.enthalpy)    # 55.45 kJ/kg
+```
+
+**Cooling load:**
+```python
+from hvacpy import (
+    Q_, Room, WallComponent, InternalGain, CoolingLoad, Orientation
+)
+
+room = Room(name="Office", floor_area=Q_(50, "m**2"),
+            ceiling_height=Q_(3, "m"))
+room.walls.append(WallComponent(
+    name="South Wall", assembly=wall,
+    area=Q_(20, "m**2"), orientation=Orientation.S,
+))
+room.internal_gains.append(
+    InternalGain(gain_type="people", count=8, activity="office_work")
+)
+
+load = CoolingLoad(room, city="london")
+print(f"Peak cooling: {load.peak_total.to('kW'):.2f}")
+print(load.breakdown())
+```
+
+**Equipment sizing (v0.4):**
+```python
+from hvacpy import Q_, SplitSystem, DuctSizer, VentilationCheck
+
+# Size a split system from the cooling load
+ss = SplitSystem(load, cop_rated=3.5)
+print(ss.summary())           # box-format sizing report
+print(ss.nominal_capacity)    # e.g. 10.0 kW
+print(ss.oversizing_warning)  # None / 'WARNING' / 'CRITICAL'
+
+# Size a main supply duct — equal friction method
+ds = DuctSizer(Q_(0.5, "m**3/s"), method="equal_friction")
+print(ds.diameter)            # e.g. 400 mm standard size
+print(ds.velocity)            # actual air velocity
+print(ds.summary())           # Dia400mm - 3.98m/s - 0.45Pa/m - or 600x400mm rect
+
+# Check ventilation compliance (ASHRAE 62.1-2022)
+vc = VentilationCheck(room, supply_airflow=Q_(0.5, "m**3/s"), space_type="office")
+print(vc.compliant)           # True / False
+print(vc.summary())
+```
+
+## Design Principles
+
+- **Correct before fast** — all equations trace to ASHRAE and ISO sources
+- **Units everywhere** — every value carries its unit, no silent conversions
+- **Practitioner language** — APIs use terms engineers actually use
+- **The engineer always decides** — hvacpy calculates and warns; it never refuses
+
+## Standards Referenced
+
+| Standard | Used in |
+|---|---|
+| ASHRAE HOF 2021 Ch.28 | Cooling loads (CLTD/CLF) |
+| ASHRAE HOF 2021 Ch.18 | Heating loads |
+| ASHRAE HOF 2021 Ch.14 | Psychrometrics |
+| ASHRAE HOF 2021 Ch.21 | Duct sizing |
+| ASHRAE HSE 2020 | Equipment sizing |
+| ASHRAE 62.1-2022 | Ventilation compliance |
+
+## Test Coverage
+
+185 tests · 92% equipment coverage · all verified against reference values
+
+## Roadmap
+
+- v0.5 — Weather data (EPW files, degree days, ASHRAE design conditions)
+- v0.6 — Data centre loads (IT load, PUE, WUE, economiser analysis)
+- v1.0 — Annual energy estimation and carbon footprint reporting
+
+## License
+
+MIT

hvacpy-0.4.0/hvacpy/__init__.py

@@ -0,0 +1,70 @@
+"""hvacpy — HVAC and building energy calculations for engineers.
+
+This package provides tools for building envelope thermal analysis,
+including material properties, assembly U-value/R-value calculations,
+and unit-aware engineering quantities.
+
+Example:
+    >>> from hvacpy import Q_, db, Assembly
+    >>> wall = Assembly('My Wall')
+    >>> wall.add_layer('brick_common', Q_(110, 'mm'))
+    >>> wall.add_layer('mineral_wool_batt', Q_(100, 'mm'))
+    >>> wall.add_layer('plasterboard_std', Q_(12.5, 'mm'))
+    >>> print(wall.u_value)
+    0.298... W / K / m²
+"""
+
+from hvacpy.units import Q_, ureg, validate_unit
+from hvacpy.exceptions import UnitError, MaterialNotFoundError
+from hvacpy.exceptions import PsychrometricInputError
+from hvacpy.exceptions import LoadCalculationError, DesignConditionsNotFoundError
+from hvacpy.exceptions import EquipmentSizingError, AirflowCalculationError, DuctSizingError
+from hvacpy.materials import Material, MaterialsDB, _DB as db
+from hvacpy.assembly import Assembly
+from hvacpy.psychrometrics import AirState, PsychChart, AirProcess
+from hvacpy.psychrometrics import (
+    dry_bulb_from_wet_bulb,
+    humidity_ratio_from_rh,
+    dew_point_from_humidity_ratio,
+)
+from hvacpy.loads import CoolingLoad, HeatingLoad, Room, Zone
+from hvacpy.loads import (
+    WallComponent as Wall,
+    WallComponent,
+    WindowComponent as Window,
+    WindowComponent,
+    InternalGain,
+    Orientation,
+)
+from hvacpy.equipment import (
+    SplitSystem, PackagedRTU, FanCoilUnit, Chiller,
+    AirSourceHeatPump, DuctSizer, VentilationCheck,
+    size_cooling_equipment, size_heat_pump,
+)
+
+# Aliases for spec compatibility
+Roof = WallComponent   # Roof is a WallComponent with is_roof=True
+Floor = WallComponent  # Floor is a WallComponent (simplified for v0.3)
+Wall = WallComponent
+Window = WindowComponent
+
+__version__ = '0.4.0'
+__all__ = [
+    'Q_', 'ureg', 'validate_unit',
+    'UnitError', 'MaterialNotFoundError', 'PsychrometricInputError',
+    'LoadCalculationError', 'DesignConditionsNotFoundError',
+    'EquipmentSizingError', 'AirflowCalculationError', 'DuctSizingError',
+    'Material', 'MaterialsDB', 'db',
+    'Assembly',
+    'AirState', 'PsychChart', 'AirProcess',
+    'dry_bulb_from_wet_bulb',
+    'humidity_ratio_from_rh',
+    'dew_point_from_humidity_ratio',
+    'CoolingLoad', 'HeatingLoad', 'Room', 'Zone',
+    'WallComponent', 'WindowComponent', 'InternalGain',
+    'Orientation', 'Wall', 'Window', 'Roof', 'Floor',
+    'SplitSystem', 'PackagedRTU', 'FanCoilUnit', 'Chiller',
+    'AirSourceHeatPump', 'DuctSizer', 'VentilationCheck',
+    'size_cooling_equipment', 'size_heat_pump',
+    '__version__',
+]

hvacpy-0.4.0/hvacpy/assembly.py

@@ -0,0 +1,249 @@
+"""Assembly module — layered building envelope elements.
+
+An Assembly represents a wall, roof, floor, or ceiling made of
+stacked material layers. It calculates total thermal resistance
+(R-value) and thermal transmittance (U-value) using the series
+resistance method from ISO 6946:2017.
+
+Example:
+    >>> from hvacpy import Q_, db, Assembly
+    >>> wall = Assembly('My Wall')
+    >>> wall.add_layer('brick_common', Q_(110, 'mm'))
+    >>> wall.add_layer('mineral_wool_batt', Q_(100, 'mm'))
+    >>> wall.add_layer('plasterboard_std', Q_(12.5, 'mm'))
+    >>> print(wall.u_value)
+    0.298... W / K / m²
+"""
+
+from __future__ import annotations
+
+from pint import Quantity
+
+from hvacpy.exceptions import UnitError
+from hvacpy.materials import Material, _DB
+from hvacpy.units import Q_, validate_unit
+
+# Surface resistance values — ISO 6946:2017 Table 1
+# Named constants per spec Section 9.2, no magic numbers.
+R_SI_WALL = 0.13  # m²K/W — horizontal heat flow
+R_SI_ROOF = 0.10  # m²K/W — upward heat flow
+R_SI_FLOOR = 0.17  # m²K/W — downward heat flow
+R_SE = 0.04  # m²K/W — all orientations
+
+_R_SI_MAP: dict[str, float] = {
+    "wall": R_SI_WALL,
+    "roof": R_SI_ROOF,
+    "floor": R_SI_FLOOR,
+}
+
+_VALID_ORIENTATIONS = frozenset(_R_SI_MAP.keys())
+
+
+class Assembly:
+    """A layered building envelope element.
+
+    Layers are ordered outside-to-inside. Surface resistances are
+    added automatically based on orientation.
+
+    Args:
+        name: Human-readable description e.g. 'Brick Cavity Wall'.
+        orientation: 'wall' | 'roof' | 'floor'. Defaults to 'wall'.
+
+    Raises:
+        ValueError: If orientation is not 'wall', 'roof', or 'floor'.
+    """
+
+    def __init__(self, name: str, orientation: str = "wall") -> None:
+        if orientation not in _VALID_ORIENTATIONS:
+            raise ValueError(
+                f"orientation must be 'wall', 'roof', or 'floor', "
+                f"got '{orientation}'"
+            )
+        self._name = name
+        self._orientation = orientation
+        self._r_si: float = _R_SI_MAP[orientation]
+        self._r_se: float = R_SE
+        # Internal layer storage — plain floats in SI units.
+        self._layers: list[dict] = []
+
+    def add_layer(
+        self,
+        material: str | Material,
+        thickness: Quantity,
+    ) -> "Assembly":
+        """Add a material layer to this assembly.
+
+        Layers are ordered as added, outside to inside.
+
+        Args:
+            material: Material key string (e.g. 'brick_common') or a
+                Material instance. String keys are case-insensitive.
+            thickness: Layer thickness as a pint Quantity with length
+                units. E.g. Q_(110, 'mm') or Q_(0.11, 'm').
+
+        Returns:
+            self, enabling method chaining.
+
+        Raises:
+            TypeError: If thickness is not a pint Quantity.
+            UnitError: If thickness does not have length dimensions.
+            ValueError: If thickness is not positive.
+            MaterialNotFoundError: If material is a string key not
+                in DB.
+        """
+        # Validate thickness type.
+        if not isinstance(thickness, Quantity):
+            raise TypeError(
+                f"thickness must be a pint Quantity, got "
+                f"{type(thickness).__name__}. "
+                f'Use Q_(value, unit) e.g. Q_(110, "mm")'
+            )
+
+        # Validate thickness dimensionality.
+        validate_unit(thickness, "[length]", "thickness")
+
+        # Convert to metres (SI).
+        thickness_m: float = thickness.to("m").magnitude
+
+        # Validate positive.
+        if thickness_m <= 0:
+            raise ValueError(
+                f"thickness must be positive, got {thickness}"
+            )
+
+        # Resolve material.
+        db_key: str | None = None
+        if isinstance(material, str):
+            db_key = material.lower()
+            mat = _DB.get(material)
+        elif isinstance(material, Material):
+            mat = material
+        else:
+            raise TypeError(
+                f"material must be a str or Material, got "
+                f"{type(material).__name__}"
+            )
+
+        conductivity: float = mat.conductivity.to("W/(m*K)").magnitude
+        r_layer: float = thickness_m / conductivity
+
+        self._layers.append({
+            "name": mat.name,
+            "key": db_key,
+            "thickness_m": thickness_m,
+            "conductivity": conductivity,
+            "r_layer": r_layer,
+        })
+
+        return self
+
+    @property
+    def r_value(self) -> Quantity:
+        """Total thermal resistance including surface resistances.
+
+        Returns:
+            R-value as a pint Quantity in m²·K/W.
+        """
+        r_total = self._r_si + self._r_se
+        for layer in self._layers:
+            r_total += layer["r_layer"]
+        return Q_(r_total, "m²*K/W")
+
+    @property
+    def u_value(self) -> Quantity:
+        """Thermal transmittance (reciprocal of R-value).
+
+        Returns:
+            U-value as a pint Quantity in W/(m²·K).
+        """
+        r_total = self.r_value.magnitude
+        return Q_(1.0 / r_total, "W/(m²*K)")
+
+    @property
+    def layers(self) -> list[dict]:
+        """Layer information as list of dicts.
+
+        Each dict contains:
+            - name (str): Material name.
+            - key (str | None): DB key if looked up, None if passed
+              as Material instance.
+            - thickness_m (float): Thickness in metres.
+            - conductivity (float): W/(m·K).
+            - r_layer (float): Layer resistance in m²K/W.
+            - r_fraction (float): Layer R as fraction of total layer
+              R (excludes surface resistances), 0.0–1.0.
+
+        Returns:
+            List of layer dicts ordered outside-to-inside.
+        """
+        r_layers_total = sum(
+            layer["r_layer"] for layer in self._layers
+        )
+
+        result: list[dict] = []
+        for layer in self._layers:
+            fraction = (
+                layer["r_layer"] / r_layers_total
+                if r_layers_total > 0
+                else 0.0
+            )
+            result.append({
+                "name": layer["name"],
+                "key": layer["key"],
+                "thickness_m": layer["thickness_m"],
+                "conductivity": layer["conductivity"],
+                "r_layer": layer["r_layer"],
+                "r_fraction": fraction,
+            })
+
+        return result
+
+    def breakdown(self) -> str:
+        """Human-readable breakdown of the assembly.
+
+        Returns:
+            Formatted string showing all layers, their resistances,
+            surface resistances, and total R/U values.
+        """
+        r_total = self.r_value.magnitude
+        u_val = self.u_value.magnitude
+
+        lines: list[str] = []
+        lines.append(
+            f"Wall: {self._name}  "
+            f"(orientation: {self._orientation})"
+        )
+        lines.append("━" * 47)
+        lines.append("  [outside]")
+        lines.append(
+            f"  Surface resistance (R_se)"
+            f"       {self._r_se:.3f} m²K/W"
+        )
+        lines.append("  " + "─" * 45)
+
+        for layer in self._layers:
+            thickness_mm = layer["thickness_m"] * 1000
+            # Format thickness — show decimal only if needed.
+            if thickness_mm == int(thickness_mm):
+                t_str = f"{int(thickness_mm)} mm"
+            else:
+                t_str = f"{thickness_mm:.1f} mm"
+
+            # Use key if available, otherwise name.
+            label = layer["key"] if layer["key"] else layer["name"]
+            lines.append(
+                f"  {label:<16s}{t_str:>8s}"
+                f"          {layer['r_layer']:.3f} m²K/W"
+            )
+
+        lines.append("  " + "─" * 45)
+        lines.append(
+            f"  Surface resistance (R_si)"
+            f"       {self._r_si:.3f} m²K/W"
+        )
+        lines.append("  [inside]")
+        lines.append("━" * 47)
+        lines.append(f"  R_total   =  {r_total:.3f} m²K/W")
+        lines.append(f"  U_value   =  {u_val:.3f} W/(m²K)")
+
+        return "\n".join(lines)

hvacpy-0.4.0/hvacpy/equipment/__init__.py

@@ -0,0 +1,47 @@
+"""hvacpy.equipment — Equipment Sizing (v0.4).
+
+ASHRAE HSE 2020 equipment sizing, ASHRAE HOF 2021 Ch.21 duct sizing,
+ASHRAE 62.1-2022 ventilation compliance.
+
+Public API:
+    SplitSystem, PackagedRTU, FanCoilUnit, Chiller
+    AirSourceHeatPump
+    DuctSizer
+    VentilationCheck
+    size_cooling_equipment, size_heat_pump (convenience functions)
+"""
+
+from hvacpy.equipment._cooling import (
+    SplitSystem, PackagedRTU, FanCoilUnit, Chiller,
+)
+from hvacpy.equipment._heatpump import AirSourceHeatPump
+from hvacpy.equipment._duct import DuctSizer
+from hvacpy.equipment._ventilation import VentilationCheck
+from hvacpy.equipment._airflow import (
+    supply_airflow_cooling,
+    supply_airflow_heating,
+    airflow_from_cooling_load,
+)
+from hvacpy.equipment._nominal_sizes import next_size_up, NOMINAL_SIZES
+
+
+def size_cooling_equipment(cooling_load, equipment_class=SplitSystem, **kwargs):
+    """Convenience function to size cooling equipment from a CoolingLoad."""
+    return equipment_class(cooling_load, **kwargs)
+
+
+def size_heat_pump(cooling_load, heating_load, **kwargs):
+    """Convenience function to size an air-source heat pump."""
+    return AirSourceHeatPump(cooling_load, heating_load, **kwargs)
+
+
+__all__ = [
+    'SplitSystem', 'PackagedRTU', 'FanCoilUnit', 'Chiller',
+    'AirSourceHeatPump',
+    'DuctSizer',
+    'VentilationCheck',
+    'size_cooling_equipment', 'size_heat_pump',
+    'supply_airflow_cooling', 'supply_airflow_heating',
+    'airflow_from_cooling_load',
+    'next_size_up', 'NOMINAL_SIZES',
+]