eureca_building package

Modules

eureca_building.air_handling_unit

This module includes the class to manage the Air Handling Unit

class eureca_building.air_handling_unit.AirHandlingUnit(name: str, mechanical_vent: MechanicalVentilation, supply_temperature: Schedule, supply_specific_humidity: Schedule, ahu_operation: Schedule, humidity_control: bool, sensible_heat_recovery_eff: float, latent_heat_recovery_eff: float, outdoor_air_ratio: float, weather: WeatherFile, thermal_zone, tag: str | None = None)[source]

Bases: object

This class manages the air handling unit. Some general variables are set as class variables while the __init__ memorizes the inputs

cp_air = 1000.0
p_atm = 101325.0
r_0 = 2501000.0
cpv = 1875.0
__init__(name: str, mechanical_vent: MechanicalVentilation, supply_temperature: Schedule, supply_specific_humidity: Schedule, ahu_operation: Schedule, humidity_control: bool, sensible_heat_recovery_eff: float, latent_heat_recovery_eff: float, outdoor_air_ratio: float, weather: WeatherFile, thermal_zone, tag: str | None = None)[source]

Air Handling Unit Constructor: creates the AHU object and memorizes the attributes (using properties set methods tho check types)

Parameters:
Raises:

  • TypeError – checks the input type

  • ValueError – checks the input type

property supply_temperature
property supply_specific_humidity
property ahu_operation
property humidity_control
property sensible_heat_recovery_eff
property latent_heat_recovery_eff
property outdoor_air_ratio
air_handling_unit_calc(t, weather, T_int, x_int)[source]

Solution of the time step calculation. It uses outdoor conditions (from WeatherFile), and zone conditions (from zone)

Parameters:

  • t (int) – timestep: int [-]

  • weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • T_int (float) – zone internal temperature: float [°C]

  • x_int (float) – zone internal specific humidity: float [kg_v/kg_da]

properties()[source]

Just a function to print the memorized conditions

checkSatCond(temp, x, p)[source]

Check Saturation Condition

This function takes as inputs temperature [°C] and humidity ratio [kg_vap/kg_as] to check if a point is outside saturation conditions

Parameters:

  • temp (float) – Temperature [°C]

  • x (float) – Specific Humidity [kg_vap/kg_as].

  • p (float) – Pressure [Pa].

Returns:

boolean (wheter saturation is reached), and Saturation Pressure [Pa].

Return type:

tuple

print_psychro_chart()[source]

Just a function to print the psychrometric chart with current transformations

eureca_building.building

This module includes functions to model the building and it includes the Building class

class eureca_building.building.Building(name: str, thermal_zones_list: list, model: str = '2C')[source]

Bases: object

This class is a wrapper for ThermalZone objects and HVAC objects

__init__(name: str, thermal_zones_list: list, model: str = '2C')[source]

Constructor of the building class. Memorizes the attributes by means of properties setter. Checks also the validity of some attributes

Parameters:

  • name (str) – Name of the building

  • thermal_zone (list) – list of ThermalZone ibjects objects

  • model (str, default 2C) – model to be used: 1C or 2C

property heating_system: System
property cooling_system: System
set_hvac_system(heating_system, cooling_system)[source]
set_hvac_system_capacity(weather_object)[source]
solve_timestep(t: int, weather: WeatherFile)[source]

Runs the thermal zone and hvac systems simulation for the timestep t

Parameters:
simulate(weather_object: WeatherFile, t_start: int = 0, t_stop: int = 8760, preprocessing_ts: int = 100, output_folder: str | None = None)[source]

Simulate a period and i stores the outputs. Calls solve_timestep method

Parameters:

  • weather_object (eureca_building.weather.WeatherFile) – WeatherFile object to use to simulate (must be appliad after the calculation of zone loads

  • t_start (int (Default first timestep of simulation)) – starting timestep

  • t_stop (int (last timestep of simulation)) – stop timestep

  • preprocessing_ts (int) – number of preprocessing timesteps

  • output_folder (str, default None) – if not None prints building results in the selected folder

Returns:

building time step results

Return type:

pandas.DataFrame

get_geojson_feature_parser()[source]

Function to get the json dictionary of building properties to stamp the output geojson

Returns:

dict with some info of the building

Return type:

dict

eureca_building.config

This module includes classes and functions to manage the CONFIG varible (the variable with simulation settings)

eureca_building.config.load_config(file: str | None = None)[source]

Function to load the config file, json file suggested

Examples

“DEFAULT”: {}, “model”: { “name”: “example_model” }, “simulation settings”: { “time steps per hour”: “2”, “simulation reference year” : “2023”, “start date”: “01-01 00:00”, “final date”: “12-31 23:00”, “heating season start”: “11-15 23:00”, “heating season end”: “04-15 23:00”, “cooling season start”: “06-01 23:00”, “cooling season end”: “09-30 23:00” }, “solar radiation settings”: { “do solar radiation calculation”: “False”, “height subdivisions”: “4”, “azimuth subdivisions”: “8”, “urban shading tolerances”: “80.,100.,80.” }

Parameters:

file (str) – string path to the file to load

Returns:

Config object from Config class

Return type:

eureca_building.config.Config

class eureca_building.config.Config[source]

Bases: ConfigParser

Inherited from configparser.ConfigParser. This class is a container for config settings.

__init__()[source]
property ts_per_hour: int
read(file)[source]

Method to create the object from the config.ini file

Parameters:

file_path (str) – file to load the config from

classmethod from_json(file_path)[source]

Class method to create the object from the config.json file

Parameters:

file_path (str) – file to load the config from

Returns:

config object

Return type:

eureca_building.config.Config

to_json(file_path)[source]

Method to print parameetrs to json

Parameters:

file_path (str) – file to print on

eureca_building.construction

This module includes class for the typical construction

class eureca_building.construction.Construction(name: str, materials_list: list, construction_type: str = 'ExtWall')[source]

Bases: object

Class to model constructions and calculate all the construction parameters: U, k_int, k_est

tot_heat_trans_coef = Outside  Inside ExtWall         25.0     7.7 Roof            25.0     7.7 GroundFloor   1000.0     7.7 IntWall          7.7     7.7 IntCeiling       6.7     6.7 IntFloor         6.7     6.7
rad_heat_trans_coef = 5.0
__init__(name: str, materials_list: list, construction_type: str = 'ExtWall')[source]

Initializes the Construction object

Parameters:

  • name (string) – name

  • materials_list (list) – list of Materials or AirGapMaterials objects (Outside -> Inside)

  • construction_type (string) – Choose from [“ExtWall”, “Roof”, “GroundFloor”, “IntWall”, “IntCeiling”]

classmethod from_U_value(name: str, u_value: float, weight_class: str = 'Medium', construction_type: str = 'ExtWall')[source]

This is a class method to create Construction object just from the U-value and weight class It creates just an equivalent material to reach the U-value

For specific heat and density, the following assumptions are considered

According to A.2.3 ISO 13786 Mass class Am [m²] Cm [J/K] k [J/(m² K)] Depth penetration [m] Spc heat [J/kg K] rho [kg/m3] Very light 2.5 80000 32000 0.1 1000 453 Light 2.5 110000 44000 0.1 1000 622 Medium 2.5 165000 66000 0.1 1000 933 Heavy 3 260000 86666.66667 0.1 1000 1226 Very heavy 3.5 370000 105714.2857 0.1 1000 1495

Parameters:

  • name (string) – name

  • u_value (float) – u value of the construction [W/(m2 K)]

  • weight_class (str) – class of weight from the following list: [“Very heavy”, “Heavy, “Medium, “Light”, “Very light”]

  • construction_type (string) – Choose from [“ExtWall”, “Roof”, “GroundFloor”, “IntWall”, “IntCeiling”]

Returns:

Construction object from these values

Return type:

eureca_building.construction.Construction

eureca_building.construction_dataset

This module includes a ConstructionDataset, a container class for materials, constructions, and windows

class eureca_building.construction_dataset.ConstructionDataset[source]

Bases: object

This class is a class to include the list of materials, construction and windows that are used in the project

materials_dict

Dict: dictionary with all Materials

Type:

dict

constructions_dict

Dict: dictionary with all Constructions

Type:

dict

windows_dict

Dict: dictionary with all Windows

Type:

dict

__init__()[source]

Generates the ConstructionDataset and the list of materials, contructions, and windows

classmethod read_excel(file)[source]

Read the Materials, Windows and Constrcutions from a spreadsheet. See and example at https://github.com/BETALAB-team/EUReCA/tree/main/eureca_building/example_scripts under materials_and_constructions.xlsx

Parameters:

file (str) – path to the file.xls

Returns:

the object with the three dictionaries including all Materials Windows and Constructions from the spreadsheet

Return type:

eureca_building.construction_dataset.ConstructionDataset

eureca_building.domestic_hot_water

This module includes functions to model Domestic Hot Water consumptions

eureca_building.domestic_hot_water.distrEventi(n, x, pdf)[source]

DEPRECATED: Not working

Parameters:

  • n –

  • x –

  • pdf –

eureca_building.domestic_hot_water.dhw_calc_calculation(volume_unit, numunits, time_step)[source]

DEPRECATED: not working

Parameters:

  • volume_unit –

  • numunits –

  • time_step –

class eureca_building.domestic_hot_water.DomesticHotWater(name: str, calculation_method: str, unit=None, schedule=None)[source]

Bases: object

DomesticHotWater object Class to manage all the calculations involved in the Domestic Hot Water consumption

__init__(name: str, calculation_method: str, unit=None, schedule=None)[source]
property calculation_method
property unit
property schedule
get_dhw_yearly_mass_flow_rate(area, number_of_units, weather)[source]

This function calculates the water and mass flow rate consumption, given the area of the building and the number of units (to be used when unit and/or method need them)

Parameters:

  • area (float) – Area of the building [m2]

  • number_of_units (int) – Number of dwellings (for residential calculation done with UNI-TS 11300

  • weather (eureca_building.weather.WeatherFile) – WeatherFile object

Returns:

tuple of numpy.arrays volume flow rate [m3/s], dhw heating demand [W]

Return type:

tuple

eureca_building.fluids_properties

This module includes dictionaries with fluid properties (air, water, vapour, fuels) To be used all over the code

eureca_building.internal_load

This module includes functions and classes to model internal heat gains

class eureca_building.internal_load.InternalLoad(name: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

Bases: object

Internal Gain Class: parent class to set some common things

__init__(name: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

Parent class for some inherited InternalLoads. It load the input and checks them throughout properties setter

Parameters:

  • name (str) – name

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object

  • tag (str) – a tag to define the type of internal load

property nominal_value
property schedule
property fraction_to_zone
property fraction_latent
property fraction_radiant
property fraction_convective
get_convective_load(*args, **kwarg) → array[source]

Just an empty method to raise an NotImplementedError Exception. This way any inherited class implements it

Parameters:

  • args –

  • kwarg –

get_radiant_load(*args, **kwarg) → array[source]

Just an empty method to raise an NotImplementedError Exception. This way any inherited class implements it

Parameters:

  • args –

  • kwarg –

get_latent_load(*args, **kwarg) → array[source]

Just an empty method to raise an NotImplementedError Exception. This way any inherited class implements it

Parameters:

  • args –

  • kwarg –

get_loads(*args, **kwargs) → list[source]

Return the convective, radiant, latent, electric load (numpy.array) If the calculation method is specific (W/m2 or px/m2) the area must be passed as kwarg (example area=12.5)

Parameters:

  • area (float) – Area in m2. pass it as kwarg: load_obj.get_loads(area = 12.5)

  • tuple – [numpy.array, numpy.array, numpy.array, numpy.array] the schedules: convective [W], radiant [W], vapour [kg_vap/s], electric [W]

class eureca_building.internal_load.People(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_latent: float = 0.55, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, metabolic_rate: float = 110, tag: str | None = None)[source]

Bases: InternalLoad

__init__(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_latent: float = 0.55, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, metabolic_rate: float = 110, tag: str | None = None)[source]

Parent class for some inherited InternalLoads. It load the input and checks them throughout properties setter

Parameters:

  • name (str) – name

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object

  • tag (str) – a tag to define the type of internal load

property unit
property metabolic_rate
get_convective_load(area=None)[source]

Returns the convective load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_radiant_load(area=None)[source]

Returns the radiant load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provide if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_latent_load(area=None)[source]

Return the latent load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_electric_load(area=None)[source]

Return the electric consumption load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

class eureca_building.internal_load.ElectricLoad(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_to_zone: float = 1.0, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, number_of_people: float | None = None, tag: str | None = None)[source]

Bases: InternalLoad

__init__(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_to_zone: float = 1.0, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, number_of_people: float | None = None, tag: str | None = None)[source]

Parent class for some inherited InternalLoads. It load the input and checks them throughout properties setter

Parameters:

  • name (str) – name

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object

  • tag (str) – a tag to define the type of internal load

property unit
property number_of_people
get_convective_load(area=None)[source]

Returns the convective load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_radiant_load(area=None)[source]

Returns the radiant load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provide if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_latent_load(area=None)[source]

Return the latent load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

get_electric_load(area=None)[source]

Return the electric consumption load numpy.array If the calculation method is specific (W/m2 or px/m2) the area must be passed

Parameters:

area (float, default None) – Area of the zone in [m2]: must be provided if the load is specific

Returns:

the schedule [W]

Return type:

numpy.array

class eureca_building.internal_load.Lights(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_to_zone: float = 1.0, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, number_of_people: float | None = None, tag: str | None = None)[source]

Bases: ElectricLoad

__init__(name: str, nominal_value: float, unit: str, schedule: Schedule, fraction_to_zone: float = 1.0, fraction_radiant: float = 0.3, fraction_convective: float = 0.7, number_of_people: float | None = None, tag: str | None = None)[source]

Parent class for some inherited InternalLoads. It load the input and checks them throughout properties setter

Parameters:

  • name (str) – name

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object

  • tag (str) – a tag to define the type of internal load

eureca_building.logs

Module that is called at the begin of the simulation to set the log file trough the logging library

eureca_building.material

This module includes classes and functions to implement materials properties

class eureca_building.material.Material(name: str, thick: float = 0.1, cond: float = 1.0, spec_heat: float = 1000.0, dens: float = 1000.0, thermal_absorptance: float = 0.9)[source]

Bases: object

Class used to define the material. Creates the material and checks the properties

__init__(name: str, thick: float = 0.1, cond: float = 1.0, spec_heat: float = 1000.0, dens: float = 1000.0, thermal_absorptance: float = 0.9)[source]

Define the material and check the properties, using setter methods

Parameters:

  • name (str) – name

  • thick (float, default 0.1) – thickness

  • cond (float, default 1.) – conductivity

  • spec_heat (float, default 1000.) – spec_heat

  • dens (float, default 1000.) – density

  • thermal_absorptance (float, default 0.9) – thermal absorptance [-]

Raises:

MaterialPropertyOutsideBoundaries – If a material parameter is not allowed.

name: str
property thick: float
property dens: float
property cond: float
property spec_heat: float
property thermal_absorptance: float
calc_capacity()[source]

Thermal capacity calculation (thickness * density * specific_heat)

calc_resistance()[source]

Thermal capacity calculation (thickness / conductivity)

calc_params()[source]

Runs self.calc_capacity() and self.calc_resistance()

class eureca_building.material.AirGapMaterial(name: str, thick: float = 0.1, thermal_resistance: float = 1.0)[source]

Bases: object

A class used to define the air gap material <

__init__(name: str, thick: float = 0.1, thermal_resistance: float = 1.0)[source]

Defines the material and check the properties. Checks properties values using setter methods

Parameters:

  • name (str) – name

  • thick (float, default 0.1) – thickness

  • thermal_resistance (float, default 1.) – thermal_resistance

Raises:

MaterialPropertyOutsideBoundaries – If a material parameter is not allowed.

name: str
property thick: float
property thermal_resistance: float

eureca_building.schedule

This module includes functions to model any schedule

class eureca_building.schedule.Schedule(name: str, schedule_type: str, schedule: array, lower_limit=None, upper_limit=None)[source]

Bases: object

Class Schedule with some generic methods for all schedules. (in particular how they are created)

__init__(name: str, schedule_type: str, schedule: array, lower_limit=None, upper_limit=None)[source]
property schedule_type
property schedule
classmethod from_daily_schedule(name: str, schedule_type: str, schedule_week_day: array, schedule_saturday: array, schedule_sunday: array, schedule_holiday: array, lower_limit=None, upper_limit=None, starting_day: int = 0, holidays: tuple = ())[source]
classmethod from_constant_value(name: str, schedule_type: str, value: float, lower_limit=None, upper_limit=None)[source]

eureca_building.schedule_properties

This file includes dictionaries to define each schedule and internal heat gains type and their properties using a JSON/Dictionary structure

eureca_building.setpoints module

This module includes functions to model setpoint of the thermal zone

class eureca_building.setpoints.Setpoint(name: str, setpoint_type: str, tag: str | None = None)[source]

Bases: object

Setpoint class

__init__(name: str, setpoint_type: str, tag: str | None = None)[source]
property setpoint_type
class eureca_building.setpoints.SetpointDualBand(name: str, setpoint_type: str, schedule_lower: Schedule, schedule_upper: Schedule, tag: str | None = None)[source]

Bases: Setpoint

__init__(name: str, setpoint_type: str, schedule_lower: Schedule, schedule_upper: Schedule, tag: str | None = None)[source]
property schedule_lower
property schedule_upper

eureca_building.surface

This module includes functions to model a 3D surface

class eureca_building.surface.Surface(name: str, vertices: tuple = ((0, 0, 0), (0, 0, 0), (0, 0, 0)), wwr=None, subdivisions_solar_calc=None, surface_type=None, construction=None, window=None, n_window_layers: int = 1)[source]

Bases: object

Class surface checks the complanarity and calculates the area. Then calculates the azimuth and tilt of the surface and set a surface type depending on the tilt angle

co planarity:

https://www.geeksforgeeks.org/program-to-check-whether-4-points-in-a-3-d-plane-are-coplanar/

the area is calculated from:

https://stackoverflow.com/questions/12642256/python-find-area-of-polygon-from-xyz-coordinates

__init__(name: str, vertices: tuple = ((0, 0, 0), (0, 0, 0), (0, 0, 0)), wwr=None, subdivisions_solar_calc=None, surface_type=None, construction=None, window=None, n_window_layers: int = 1)[source]

Creates the surface object. Checks all the inputs using properties setter methods

Parameters:

  • name (str) – Name.

  • vertices (tuple, default ((0, 0, 0), (0, 0, 0), (0, 0, 0))) – List of vertices coordinates [m]. The default is ([0, 0, 0], [0, 0, 0], [0, 0, 0]).

  • wwr (float, default None) – window to wall ratio (between and 0 and 1). The default is 0.0.

  • subdivisions_solar_calc (dict, default None) – Something like { ‘azimuth_subdivisions’: 8, ‘height_subdivisions’: 3, } keys: azimuth_subdivisions : int, optional Number of azimuth discretization for radiation purposes. The default is 8. height_subdivisions : int, optional Number of height discretization for radiation purposes. The default is 3.

  • surface_type (str, default None) – Type of surface ‘ExtWall’ or ‘GroundFloor’ or ‘Roof’. If not provided autocalculate.

  • construction (eureca_building.construction.Construction) – the construction object with the materials

  • window (eureca_building.window.SimpleWindow) – the Window object with the materials

property subdivisions_solar_calc: dict
property surface_type
property construction
property window
max_height()[source]

Calculates max height from the most high vertex

min_height()[source]

Calculates max height from the most low vertex

get_VDI6007_surface_params(asim=None)[source]

Calculates R and C using VDI6007 method.

Parameters:

asim (bool) – Whether the surface is asimmetric (True) or not (False)

Returns:

R, C -> Thermal Resistance and Capacity

Return type:

tuple

get_surface_external_radiative_coefficient()[source]

Returns the radiative heat exchange coefficient.

Return type:

float

check_surface_coincidence(other_surface)[source]

Check if two surface are coincident returning True or False

Parameters:

other_surface (eureca_building.surface.Surface) – another surface object

Returns:

Are the surfaces coincident? True/False

Return type:

bool

calculate_intersection_area(other_surface)[source]

Calculates the area between two adjacent surfaces reference: https://stackoverflow.com/questions/39003450/transform-3d-polygon-to-2d-perform-clipping-and-transform-back-to-3d

Parameters:

other_surface (eureca_building.surface.Surface) – another surface object

Returns:

The intersection area [m2]

Return type:

float

reduce_area(area_to_reduce)[source]

Reduces the area of the surface by an input area

Parameters:

area_to_reduce (float) – the area to subtract [m2] to the total area

class eureca_building.surface.SurfaceInternalMass(name: str, area: float = 0.0, surface_type=None, construction=None)[source]

Bases: object

Class to define a surface for thermal capacity using area and surface type with a specific geometry

__init__(name: str, area: float = 0.0, surface_type=None, construction=None)[source]

It creates the SurfaceInternalMass object, like the Surface class, but without vertexes and geometry

Parameters:

  • name (string) – name of the surface

  • area (float, default 0.) – area of the internal surface

  • surface_type (str, default None) – Type of internal surface: ‘IntWall’ or ‘IntCeiling’

  • construction (eureca_building.construction.Construction) – The construction to be assigned to the SurfaceInternalMass

property surface_type
property construction
get_VDI6007_surface_params(asim=False)[source]

Calculates R and C using VDI6007 method.

Parameters:

asim (bool) – Whether the surface is asimmetric (True) or not (False)

Returns:

R, C -> Thermal Resistance and Capacity

Return type:

tuple

eureca_building.systems

File with HVAC systems classes

class eureca_building.systems.System(*args, **kwargs)[source]

Bases: object

Father class for HVAC systems classes Defines an interface to force inherited class to implement mandatory methods

abstract __init__(*args, **kwargs)[source]
abstract set_system_capacity()[source]
abstract solve_system()[source]
abstract property electric_consumption
abstract property gas_consumption
abstract property wood_consumption
abstract property oil_consumption
property system_type
class eureca_building.systems.IdealLoad(*args, **kwargs)[source]

Bases: System

Class IdealLoad is for the ideal zone balance. This class passes all methods.

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

IdealLoad init method. No input needed

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Set system capacity method.

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

Solve the system power for the time step

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.CondensingBoiler(*args, **kwargs)[source]

Bases: System

Class CondensingBoiler. This method considers a generic Condensing Boiler as the heating system of the entire building following UNI-TS 11300:2 - 2008

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes for the method are initialized

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Sets system design power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate Condensing Boiler power and losses following the Standard UNI-TS 11300:2 - 2008

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.TraditionalBoiler(*args, **kwargs)[source]

Bases: System

Class TraditionalBoiler. This class considers a generic Traditional Boiler as the heating system of the entire building following UNI-TS 11300:2 - 2008

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes for the method

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Sets system design power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate Traditional Boiler losses following the Standard UNI-TS 11300:2 - 2008

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.SplitAirCooler(*args, **kwargs)[source]

Bases: System

SplitAirCooler class. This class considers a generic Split Air Conditioner as the cooling system of the entire building following UNI-TS 11300:3 - 2010

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes for the method

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Choice of system size based on estimated nominal Power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate Split Air Cooler electrical power following the Standard UNI-TS 11300:3 - 2010

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.ChillerAirtoWater(*args, **kwargs)[source]

Bases: System

ChillerAirtoWater class. This method considers a generic Air-to-water Chiller as the cooling system of the entire building following UNI-TS 11300:3 - 2010

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes for the method

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Choice of system size based on estimated nominal Power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculates Air to Water Chiller electrical power following the Standard UNI-TS 11300:3 - 2010

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.SplitAirConditioner(*args, **kwargs)[source]

Bases: System

SplitAirConditioner class

This method considers a generic Split Air Conditioner as the cooling system of the entire building following two documents of literature

Berend Jan Christiaan van Putten, Nariman Mahdavi, Julio H. Braslavsky, An Analytical Model for Demand Response of Variable-Speed Air Conditioners, IFAC-PapersOnLine, Volume 51, Issue 28, 2018, Pages 426-431, ISSN 2405-8963, https://doi.org/10.1016/j.ifacol.2018.11.740. (https://www.sciencedirect.com/science/article/pii/S2405896318334608)

https://ieeexplore.ieee.org/document/7515217 N. Mahdavi, J. H. Braslavsky and C. Perfumo, “Mapping the Effect of Ambient Temperature on the Power Demand of Populations of Air Conditioners,” in IEEE Transactions on Smart Grid, vol. 9, no. 3, pp. 1540-1550, May 2018, doi: 10.1109/TSG.2016.2592522.

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes for the method

Parameters:

  • args –

  • kwargs –

set_system_capacity(design_power, weather)[source]

Choice of system size based on estimated nominal Power for air conditioner WITHOUT inverter

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate from literature: Split Air Cooler condensing power

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.Heating_EN15316(*args, **kwargs)[source]

Bases: System

Class Heating_EN15316. This method considers a generic heating system as the heating system of the entire building following EN 15316.

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes are set The heating_system_key label must be passed as kwargs. Example: Heating_EN15316(heating_system_key = “Traditional Gas Boiler, Single, Low Temp Radiator”)

Parameters:

  • args (list) – list of optional arguments

  • kwargs (dict) – kwargs must include {heating_system_key : string_of_heating_system}

set_system_capacity(design_power, weather)[source]

‘Choice of system size based on estimated nominal Power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate the system power for each time step

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

class eureca_building.systems.Cooling_EN15316(*args, **kwargs)[source]

Bases: System

Class Cooling_EN15316. This method considers a generic cooling system as the heating system of the entire building following EN 15316.

gas_consumption = 0
electric_consumption = 0
wood_consumption = 0
oil_consumption = 0
__init__(*args, **kwargs)[source]

init method. Set some attributes are set The cooling_system_key label must be passed as kwargs. Example: Cooling_EN15316(cooling_system_key = “A-W chiller, Centralized, Radiant surface”)

Parameters:

  • args –

  • kwargs – kwargs must include {cooling_system_key : string_of_cooling_system}

set_system_capacity(design_power, weather)[source]

‘Choice of system size based on estimated nominal Power

Parameters:
solve_system(heat_flow, weather, t, T_int, RH_int)[source]

This method allows to calculate the system power for each time step

Parameters:

  • heat_flow (float) – required power [W]

  • Weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • t (int) – Simulation time step

  • T_int (float) – Zone temperature [°]

  • RH_int (float) – Zone relative humidity [%]

eureca_building.systems_info

File with HVAC systems csvs This is an internal class, where typical systems performances are stored in a disctionary, using csv parsed strings

eureca_building.thermal_zone

This module includes functions to model the thermal zone

class eureca_building.thermal_zone.ThermalZone(name: str, surface_list: list, net_floor_area=None, volume=None, number_of_units: int = 1)[source]

Bases: object

Thermal zone class. Manages all the models and time step solution of the sensible and latent systems

__init__(name: str, surface_list: list, net_floor_area=None, volume=None, number_of_units: int = 1)[source]

Int method. Creates the thermal zone object from a list of eureca_building.surface.Surface. Checks the inputs through properties

Parameters:

  • name (str) – Name of the zone

  • surface_list (list) – list of eureca_building.surface.Surface or eureca_building.surface.SurfaceInternalMass objects

  • net_floor_area (float, default None) – footprint area of the zone in m2. If None searches for a GroundFloor surface

  • volume (float, default None) – volume of the zone in m3. If None sets 0 m3.

property number_of_units: int
add_temperature_setpoint(setpoint, mode='air')[source]

Function to associate a setpoint objects to the thermal zone

Parameters:

  • setpoint (eureca_building.setpoint.Setpoint) – object of the class Setpoint

  • mode (str) – setpoint mode: [‘air’, ‘operative’, ‘radiant’]. FOR NOW ONLY AIR IMPLEMENTED

property temperature_setpoint
property temperature_setpoint_mode
add_humidity_setpoint(setpoint)[source]

Function to associate a humidity setpoint to the thermal zone

Parameters:

setpoint (eureca_building.setpoint.Setpoint) – object of the class Setpoint

property humidity_setpoint
property humidity_setpoint_mode
static get_specific_humidity(air_t, air_rh, p_atm)[source]

Static method. Give the specific humidity from temperature, relative humidity, and atmospheric pressure

Parameters:

  • air_t (float) – air temperature [°C]

  • air_rh (float) – air relative humidity [-]

  • p_atm (float) – atmospheric pressure [pa]

Returns:

specific humidity [kg_vap/kg_da]

Return type:

float

add_internal_load(*internal_load)[source]

Function to associate a load to the thermal zone

Parameters:

internal_load (eureca_building.internal_load.InternalLoad) – As many eureca_building.internal_load.InternalLoad can be provided

extract_convective_radiative_latent_electric_load()[source]

From the internal loads calculates 3 arrays (len equal to 8769 * number of time steps per hour): { convective [W] : np.array radiative [W] : np.array latent [kg_vap/s] : np.array }

Return type:

dict

add_infiltration(*infiltration)[source]

Function to associate a natural ventilation object to the thermal zone

Parameters:

natural_ventilation (eureca_building.ventilation.Infiltration) – As many eureca_building.ventilation.Infiltration can be provided

calc_infiltration(weather)[source]

From the infiltration_list calculates 2 arrays (len equal to 8769 * number of time steps per hour): { air mass flow rate [kg/s] : np.array vapour mass flow rate [kg/s] : np.array }

Parameters:

weather (eureca_building.weather.WeatherFile) – WeatherFile object

Return type:

dict

add_air_handling_unit(ahu, weather)[source]

Function to associate an air_handling_unit object to the thermal zone

Parameters:
property air_handling_unit: AirHandlingUnit
add_domestic_hot_water(weather_obj, *dhw_obj)[source]

Function to associate a domestic hot water object to the thermal zone

Parameters:
print_ISO13790_params()[source]

Just a beuty print of ISO 13790 parameters

Return type:

str

print_VDI6007_params()[source]

Just a beuty print of VDI6007 parameters

Return type:

str

calculate_zone_loads_ISO13790(weather)[source]

Calculates the heat gains (internal and solar) on the three nodes of the ISO 13790 network Vectorial calculation

Parameters:

weather (eureca_building.weather.WeatherFile) – WeatherFile object

calculate_zone_loads_VDI6007(weather)[source]

Calculates zone loads for the vdi 6007 standard Also the external equivalent temperature

Parameters:

weather (eureca_building.weather.WeatherFile) – WeatherFile obj

sensible_balance_1C(flag, Hve, T_e, T_sup_AHU, phi_load, sigma=[0.0, 1.0], T_set=20.0, phi_HC_set=0.0)[source]

Solves ISO 13790 network for a specific time step

Parameters:

  • flag (string) – flag to set the calculation method string ‘Tset’ or ‘phiset’

  • Hve (list) – list of two ositive floats. Ventilation and infiltration heat tranfer coeff [W/K] [Hve_vent, Hve_inf]

  • T_e (float) – timestep external temperature [°C]

  • T_sup_AHU (float) – timestep ventilation supply temperature [°C]

  • phi_load (list) – list of three floats. The load on the three nodes network (ia, sm, m respectively) [W] [phi_ia, phi_sm, phi_m]

  • sigma (list, default [0., 1.]) – list of 2 floats portion of the heating/cooling load to: sigma[0]: radiant to surface sigma[1]: convective to air node sum must be 1

  • T_set (float, default 20.) – time step setpoint temperature [°C]

  • phi_HC_set (float, default 0.) – time step thermal load to the ambient [W]

Returns:

array with system load, air temperature, surfaces equivalent temperature and mass equivalent temperature e.g. [ demand [W], T_air [°C], T_s [°C], T_m [°C] ]

Return type:

numpy.array

sensible_balance_2C(flag, Hve, T_e, T_e_eq, T_sup_AHU, phi_load, sigma=[0.0, 0.0, 1.0], T_set=20.0, phi_HC_set=0.0)[source]

Sensible2C solves the linear system (Y*x = q) of VDI6007 at each iteration with a given setpoint temperature or (*)Note: if phi_HC > 0 HEATING LOAD; phi_HC < 0 COOLING LOAD.

Parameters:

  • flag (string) – string ‘Tset’ or ‘phiset’

  • Hve (list) – list of two ositive floats. Ventilation and infiltration heat tranfer coeff [W/K] [Hve_vent, Hve_inf]

  • T_e (float) – time step external temperature [°C]

  • T_e_eq (float) – time step external equivalent temperature [°C]

  • T_sup_AHU (float) – time step ventilation supply temperature [°C]

  • phi_load (list) – list of three floats: internal and solar gains, three components (convective, aw and iw)[W] [phi_conv, phi_aw, phi_iw]

  • sigma (list, default [0., 0., 1.]) – list of 3 floats portion of the heating cooling load to: sigma[0]: radiant to non adiabatic sigma[1]: radiant to adiabatic sigma[2]: convective to air node The sum must be 1

  • T_set (float, default 20.) – time step setpoint of considered thermal zone [°C]

  • phi_HC_set (float, default 0.) – time step Thermal load entering in the system [W]

Returns:

temperature nodes of the RC model: theta_m_aw thermal mass of AW building components [°C] theta_s_aw surface of AW building components [°C] theta_lu_star No physical meaning (node obtained from the delta–>star transformation) [°C] theta_I_lu internal air temperature [°C] <— WHAT WE WILL EXTRACT AS OUTPUT outside the function Q_hk_ges heating/cooling load for maintaining the given setpoint temperature [W] <— WHAT WE WILL EXTRACT AS OUTPUT outside the function theta_s_iw surface of IW building components [°C] theta_m_iw thermal mass of IW building components [°C] e.g. [ theta_m_aw [°C], theta_s_aw [°C], theta_lu_star [°C], theta_I_lu [°C], Q_hk_ges [W] theta_s_iw [°C], theta_m_iw [°C], ]

Return type:

numpy.array

latent_balance(flag, G_ve, x_ext, x_sup, vapour_int_load, t_air_int, p_atm, rh_int_set=0.5, phi_HC_set=0.0)[source]

Solves latent balance (vapour balance) for a specific time step

Parameters:

  • flag (str) – calculation mode”phiset” or “rhset”

  • G_ve (list) – List of two floats: ventialtion and infiltration mass flow rate [kg/s] [G_ve_vent, G_ve_inf]

  • x_ext (float) – time step external specific humidity [kg_vap/kg_da]

  • x_sup (float) – time step supply specific humidity [kg_vap/kg_da]

  • vapour_int_load (float) – time step vapour mass flow rate of internal loads [kg/s]

  • t_air_int (float) – time step air temperature [°C]

  • p_atm (float) – time step air temperature [°C]

  • rh_int_set (float, default 0.5) – relative humidity set point [-]

  • phi_HC_set (float, default 0.) – hvac latent load [W]

Returns:

array with zone specific humidity [kg_v, kg_as], zone relative humidity [-], latent demand [W] e.g. [ zone specific humidity [kg_v, kg_as], zone relative humidity [-], latent demand [W], ]

Return type:

tuple

reset_init_values(T: float = 15.0, X: float = 0.0105)[source]

This method allows to reset temperatures starting values, for the first calculation

Parameters:

  • T (float, default 15.) – Temperature to set as temperature mass [°C]

  • X (float, default 0.0105) – Specific humidity [kg_v/kg_as]

reset_init_values_VDI()[source]

This method allows to reset temperatures starting values, according to VDI tests Starting T 22 °C Starting x 0.0105 kg_v/kg_as

solve_timestep(t, weather, model='2C')[source]

Solves the thermal zone t - time step

Parameters:
design_heating_load(t_ext_design)[source]

Preliminary calculation to calculate the heating design temperature. Static calculation considering the product UA of all surfaces, the maximum infiltration flow rate, and the outdoor design temperature

Parameters:

t_ext_design (float) – outdoor design temperature [°C]

design_sensible_cooling_load(weather, model='2C')[source]

This method calculates the peak cooling according to the thermal load and weather of the thermal zone In order to do this, checks the hottest day (outdoor air temperature for 1C model, equivalent temperature for 2C, including also solar loads) And runs a simulation of the two days in between this maximum (similar to Carrier method, but using the 1C or 2C method)

Parameters:
get_zone_info()[source]

Just to print a beuty string of some info of the zone

eureca_building.units

List of physic properties with their unit

eureca_building.ventilation

This module includes functions to model natural ventilation and infiltration

eureca_building.ventilation.calc_neutral_plane_nat_vent(x, *data)[source]

TODO : Giacomo per favore riempi questa

Parameters:

  • x (float) –

  • data (tuple) –

class eureca_building.ventilation.Ventilation(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

Bases: object

Ventilation class

__init__(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

VentilationObject creation

Parameters:

  • name (str) – name

  • unit (str) – value of the unit: [“Vol/h”, “kg/s”, “kg/(m2 s)”, “m3/s”, “m3/(m2 s)”]

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object with a fractional schedule

  • tag (str, default None) – a tag to define the type of internal load

property nominal_value
property schedule
property unit
get_air_flow_rate(area=None, volume=None) → array[source]

Returns ventilation air flow rate in kg/s. This method might be overridden by a child class

Parameters:

  • area (float, default None) – [m2]: must be provided if the load is area specific

  • volume (float, default None) – [m3]: must be provided if the load is volume specific

Returns:

air flow rate in kg/s

Return type:

numpy.array

get_vapour_flow_rate(weather, area=None, volume=None) → array[source]

Calc the vapour mass flow rate in kg/s

Parameters:

  • weather (eureca_building.weather.WeatherFile) – Weather object

  • area (float, default None) – [m2]: must be provided if the load is area specific

  • volume (float, default None) – [m3]: must be provided if the load is volume specific

Returns:

vapour flow rate in kg/s

Return type:

numpy.array

get_flow_rate(weather, *args, **kwargs) → list[source]

Return the air and vapour flow rate from natural ventilation. weather object must be passed

Parameters:
Returns:

tuple of two numpy.array (air and vapour flow rates)

Return type:

tuple

class eureca_building.ventilation.Infiltration(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

Bases: Ventilation

This is just an inherited version of the Ventilation class, without any change

class eureca_building.ventilation.NaturalVentilation(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None, surfaces_with_opening: list | None = None, weather: WeatherFile | None = None)[source]

Bases: Ventilation

Inheritaded from the Ventilation class

__init__(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None, surfaces_with_opening: list | None = None, weather: WeatherFile | None = None)[source]

Init method. Call the Ventilation super() init and then store few more input

Parameters:

  • name (str) – name

  • unit (str) – value of the unit: [“Vol/h”, “kg/s”, “kg/(m2 s)”, “m3/s”, “m3/(m2 s)”]

  • nominal_value (float) – the value to be multiplied by the schedule

  • schedule (eureca_building.schedule.Schedule) – Schedule object with a fractional schedule

  • tag (str, default None) – a tag to define the type of internal load

  • surfaces_with_opening (list) – list of eureca_building.surface.Surface objects (those considered for the natural ventilation purposes

  • weather (eureca_building.weather.WeatherFile) – Weather object

property schedule
property unit
get_air_flow_rate()[source]

Not implemented for Natural Ventilation

get_vapour_flow_rate()[source]

Not implemented for Natural Ventilation

get_flow_rate()[source]

Not implemented for Natural Ventilation

define_pressure_coef(weather, surfaces_with_opening)[source]

TODO : Per Giacomo compila la documentazione

Parameters:

  • weather (eureca_building.weather.WeatherFile) – WeatherFile object

  • surfaces_with_opening (list) – list of eureca_building.surface.Surface objects (those considered for the natural ventilation purposes

get_timestep_ventilation_mass_flow(ts, t_zone, weather)[source]

TODO : Per Giacomo compila la documentazione

Parameters:
class eureca_building.ventilation.MechanicalVentilation(name: str, unit: str, nominal_value: float, schedule: Schedule, tag: str | None = None)[source]

Bases: Ventilation

The same as Natural/Ventilation object but different check on units

property unit

eureca_building.weather

This module includes classes and functions to manage weather file

class eureca_building.weather.WeatherFile(epw: str, year=None, time_steps: int = 1, irradiances_calculation: bool = True, azimuth_subdivisions: int = 8, height_subdivisions: int = 3, urban_shading_tol=[80.0, 100.0, 80.0])[source]

Bases: object

This class is a container for all weather data. It processes the epw file to extract arrays of temperature, wind, humidity etc……

__init__(epw: str, year=None, time_steps: int = 1, irradiances_calculation: bool = True, azimuth_subdivisions: int = 8, height_subdivisions: int = 3, urban_shading_tol=[80.0, 100.0, 80.0])[source]

Initialize weather obj. It processes the epw file to extract arrays of temperature, wind, humidity etc……

Parameters:

  • epw_name (str) – path of the epw file.

  • year (int, default None) – the year of simulation. it is used only to create a pd.DataFrame.

  • time_steps (int, default 1) – number of time steps in a hour.

  • irradiances_calculation (bool, default False) – Whether to do or not the irradiances calculation

  • azimuth_subdivisions (int, default 8) – number of the different direction (azimuth) solar radiation will be calculated

  • height_subdivisions (int, default 3) – number of the different direction (solar height) solar radiation will be calculated

  • urban_shading_tol (list, default [80.,100.,80.]) – list of three floats with the tolerances for urban shading calc (azimuth, distance, theta)

irradiances_calculation()[source]

Internal method to tun the irrandiances calculation

eureca_building.window

This module includes classes and functions to solve the window system

class eureca_building.window.SimpleWindow(name: str, u_value: float, solar_heat_gain_coef: float, visible_transmittance: float = 0.9, frame_factor: float = 0.9, shading_coef_int: float = 0.05, shading_coef_ext: float = 0.05)[source]

Bases: object

Defines the simple window model with all its characteristics and apply the simple glazing model to estimates the curve of SHGC(theta)

__init__(name: str, u_value: float, solar_heat_gain_coef: float, visible_transmittance: float = 0.9, frame_factor: float = 0.9, shading_coef_int: float = 0.05, shading_coef_ext: float = 0.05)[source]

init method. Stores the data and checks them

Parameters:

  • name (str) – name.

  • u_value (float) – u_value [W/(m2 K)].

  • solar_heat_gain_coef (float) – [-].

  • visible_transmittance (float, default 0.9) – [-]. The default is 0.9.

  • frame_factor (float, default 0.9) – [-]. The default is 0.9.

  • shading_coef_int (float, default 0.05) – [-]. The default is 0.05.

  • shading_coef_ext (float, default 0.05) – [-]. The default is 0.05.

property u_value: float
property solar_heat_gain_coef: float
property visible_transmittance: float
property frame_factor: float
property shading_coef_int: float
property shading_coef_ext: float
simpleGlazingModel()[source]

Description: This function implement the simplified model for glazing that is used in energy plus The output variables are: - 4 vectors containing solar transmittance, reflectance, absorptance, SHGC in function of the incident angle from 0 to 90, with a 10 step - the solar transmittance, reflectance and absorption at normal incident; - the equivalent conductivity [W/m K] of the glazing material; - the equivalent thickness [m] of the glazing layer; - the visible reflectance on the front side and back side; - the inward flowing fraction;

———ATTENTION———– For some combinations of variable SHGC and U the curves are not physically possible,(reflectance > 1). For this reason it is necessary to manipulate the final reflectance and transmittance vectors to manage the curves. It is also necessary to force the absolute reflectance to be 1 and the absolute transmittance to be 0 for the perpendicular incidence.

Controlling input variable

Module contents