eureca_building package

Modules

eureca_building.air_handling_unit

This module includes the class to manage the Air Handling Unit

eureca_building.air_handling_unit.__maintainer__ = 'Enrico Prataviera'

IMPORTING MODULES

class eureca_building.air_handling_unit._BaseAirHandlingUnit

Bases: object

This class is a class to be inherited by different Mechanical Ventilation Unit objects. Some generic methods are stored

cp_air = 1000.0

rho_air = 1.2

p_atm = 101325.0

r_0 = 2501000.0

cpv = 1875.0

checkSatCond(temp, x, p)

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

electric_consumption_based_on_mass_flow_rate(mass_flow)

######################## Warning ############################# Typical electric consumption from catalogue data. This method calculates a very rough estimation of the electric consumption based on the mass flow rate. It does not account for real pressure drops or other phenomena

Parameters:

mass_flow (numpy.array) – ventialation mass flow rate [kg/s]

Returns:

consumption [W].

Return type:

np.array

properties()

Just a function to print the memorized conditions

_psychro_plot()

Just a function to get a psychrometric chart (internal use only)

print_psychro_chart()

Just a function to print the psychrometric chart with current transformations

__dict__ = mappingproxy({'__module__': 'eureca_building.air_handling_unit', '__doc__': 'This class is a class to be inherited by different Mechanical Ventilation Unit objects.\n    Some generic methods are stored\n    ', 'cp_air': 1000.0, 'rho_air': 1.2, 'p_atm': 101325.0, 'r_0': 2501000.0, 'cpv': 1875.0, 'checkSatCond': <function _BaseAirHandlingUnit.checkSatCond>, 'electric_consumption_based_on_mass_flow_rate': <function _BaseAirHandlingUnit.electric_consumption_based_on_mass_flow_rate>, 'properties': <function _BaseAirHandlingUnit.properties>, '_psychro_plot': <function _BaseAirHandlingUnit._psychro_plot>, 'print_psychro_chart': <function _BaseAirHandlingUnit.print_psychro_chart>, '__dict__': <attribute '__dict__' of '_BaseAirHandlingUnit' objects>, '__weakref__': <attribute '__weakref__' of '_BaseAirHandlingUnit' objects>, '__annotations__': {}})

__doc__ = 'This class is a class to be inherited by different Mechanical Ventilation Unit objects.\n    Some generic methods are stored\n    '

__module__ = 'eureca_building.air_handling_unit'

__weakref__

list of weak references to the object (if defined)

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)

Bases: _BaseAirHandlingUnit

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

__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)

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

Parameters:

• name (str) – name of the Air Handling Unit

• mechanical_vent (eureca_building.ventilation.MechanicalVentilation) – ventialation object to define air flow rate

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

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

• ahu_operation (eureca_building.schedule.Schedule) – Schedule object to define opeartion (-1 cooling, 1 heating, 0 fan mode)

• humidity_control (bool) – whether do humidification/dehumidification

• sensible_heat_recovery_eff (float) – sensible heat recovery efficiency, must be between 0 and 1

• latent_heat_recovery_eff (float) – sensible heat recovery efficiency, must be between 0 and 1

• outdoor_air_ratio (float) – outdoor air fraction, must be between 0 and 1

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

• thermal_zone (eureca_building.thermal_zone.ThermalZone) – ThermalZone object

• tag (str) – possible tags

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

__annotations__ = {}

__doc__ = 'This class manages the air handling unit.\n    Some general variables are set as class variables while the __init__ memorizes the inputs\n    '

__module__ = 'eureca_building.air_handling_unit'

property latent_heat_recovery_eff

property outdoor_air_ratio

air_handling_unit_calc(t, weather, T_int, x_int)

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]

class eureca_building.air_handling_unit.HeatRecoveryUnit(name: str, mechanical_vent: MechanicalVentilation, sensible_heat_recovery_eff: float, latent_heat_recovery_eff: float, weather: WeatherFile, thermal_zone, tag: str | None = None)

Bases: _BaseAirHandlingUnit

This class manages a heat recovery unit (only fans and heat recovery, without active heating/cooling of air.

__annotations__ = {}

__doc__ = 'This class manages a heat recovery unit (only fans and heat recovery, without active heating/cooling of air.\n    '

__module__ = 'eureca_building.air_handling_unit'

__init__(name: str, mechanical_vent: MechanicalVentilation, sensible_heat_recovery_eff: float, latent_heat_recovery_eff: float, weather: WeatherFile, thermal_zone, tag: str | None = None)

Heat recovery unit Constructor: creates the HRU object and memorizes the attributes (using properties set methods tho check types)

Parameters:

• name (str) – name of the Air Handling Unit

• mechanical_vent (eureca_building.ventilation.MechanicalVentilation) – ventialation object to define air flow rate

• sensible_heat_recovery_eff (float) – sensible heat recovery efficiency, must be between 0 and 1

• latent_heat_recovery_eff (float) – sensible heat recovery efficiency, must be between 0 and 1

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

• thermal_zone (eureca_building.thermal_zone.ThermalZone) – ThermalZone object

• tag (str) – possible tags

Raises:

• TypeError – checks the input type

• ValueError – checks the input type

property sensible_heat_recovery_eff

property latent_heat_recovery_eff

air_handling_unit_calc(t, weather, T_int, x_int)

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]

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')

Bases: object

This class is a wrapper for ThermalZone objects and HVAC objects

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

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 _thermal_zones_list: list

property _model: str

property heating_system: System

property cooling_system: System

set_hvac_system(heating_system, cooling_system, **kwargs)

set_hvac_system_capacity(weather_object)

__dict__ = mappingproxy({'__module__': 'eureca_building.building', '__doc__': 'This class is a wrapper for ThermalZone objects and HVAC objects\n    ', '__init__': <function Building.__init__>, '_thermal_zones_list': <property object>, '_model': <property object>, 'heating_system': <property object>, 'cooling_system': <property object>, 'set_hvac_system': <function Building.set_hvac_system>, 'set_hvac_system_capacity': <function Building.set_hvac_system_capacity>, 'add_pv_system': <function Building.add_pv_system>, 'add_solar_thermal': <function Building.add_solar_thermal>, 'solve_timestep': <function Building.solve_timestep>, 'simulate': <function Building.simulate>, 'simulate_quasi_steady_state': <function Building.simulate_quasi_steady_state>, 'get_geojson_feature_parser': <function Building.get_geojson_feature_parser>, '__dict__': <attribute '__dict__' of 'Building' objects>, '__weakref__': <attribute '__weakref__' of 'Building' objects>, '__annotations__': {}})

__doc__ = 'This class is a wrapper for ThermalZone objects and HVAC objects\n    '

__module__ = 'eureca_building.building'

__weakref__

list of weak references to the object (if defined)

add_pv_system(weather_obj)

PV production

add_solar_thermal(weather_obj)

solve_timestep(t: int, weather: WeatherFile)

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

Parameters:

• t (int) – timestep

• weather_object (eureca_building.weather.WeatherFile) – WeatherFile object to use to simulate

simulate(weather_object: WeatherFile, t_start: int = 0, t_stop: int = 8760, preprocessing_ts: int = 100, output_folder: str | None = None, output_type: str = 'csv')

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

• output_type (str, default "csv") – parquet or csv as output file

Returns:

building time step results

Return type:

pandas.DataFrame

simulate_quasi_steady_state(weather_object: WeatherFile, output_folder: str | None = None, output_type: str = 'csv')

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

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

• output_type (str, default "csv") – parquet or csv as output file

Returns:

building time step results

Return type:

pandas.DataFrame

get_geojson_feature_parser()

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)

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 shading 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

Bases: ConfigParser

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

__init__()

property ts_per_hour: int

read(file)

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)

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

__abstractmethods__ = frozenset({})

__doc__ = 'Inherited from configparser.ConfigParser. This class is a container for config settings.\n    '

__module__ = 'eureca_building.config'

_abc_impl = <_abc._abc_data object>

to_json(file_path)

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')

Bases: object

Represents a multi-layer building construction, including methods to calculate:

• Thermal resistance and U-values

• Thermal capacitance (ISO 13790, VDI 6007)

• Transfer matrix parameters for dynamic simulation

Used for walls, roofs, floors, and internal partitions.

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')

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”]

_ISO13790_params()

Calculates ISO13790 params: k_int, k_est

_VDI6007_params()

Calculates vdi6007 params

Section 6.3

vdi6007params Calculates the parameters (thermal resistance and thermal capacitance) associated with the building envelope LP according to the 2C model of standard VDI 6007

Inputs (already attributes of the class)

Matrix LP describes building envelope; each row is a building element. Columns are thickness (s), thermal conductivity (cond), density (rho) and specific heat (cp) Total surface area S of wall with building envelope LP Flag ‘asim’ indicates whether building component LP is asimmetrically loaded (asim = 1) or not (asim = 0) because in the first case C1_korr must be considered instead of C1

Subscripts AW external walls and internal walls facing unheated areas IW internal walls

Period T_bt T_bt = 7 days for a single building component; T_bt = 2 days for building components where thermal storage masses are thermally covered on the room side (eg suspended ceilings) Calculation are conducted with both periods, then the resulting parameters R1 and C1 are compared and the right T_bt is chosen according to the criterion given in the standard

Outputs

R1 - dynamic rhermal resistance [K/W] C1 - dynamic thermal capacity [K/W] Rw - static specific thermal resistance [(m2 K) / W]

Determine thermal resistance R and thermal capacitance of layers, which are memorized as attributes

_VDI6007_surface_params(sup, asim)

Calculates vdi6007 params, those which are calculated using the area of the surface

Section 6.4

Parameters:

• sup (float) – area of the surface [m2]

• asim (bool) – Is the surface non-adiabatic? True/False

Returns:

R1,C1: tuple of floats Resistance and capacitance R1 and C1

Return type:

tuple

__str__()

Just a print method

__dict__ = mappingproxy({'__module__': 'eureca_building.construction', '__doc__': '\n        Represents a multi-layer building construction, including methods to calculate:\n            - Thermal resistance and U-values\n            - Thermal capacitance (ISO 13790, VDI 6007)\n            - Transfer matrix parameters for dynamic simulation\n            \n        Used for walls, roofs, floors, and internal partitions.\n    ', '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__': <function Construction.__init__>, '_ISO13790_params': <function Construction._ISO13790_params>, '_VDI6007_params': <function Construction._VDI6007_params>, '_VDI6007_surface_params': <function Construction._VDI6007_surface_params>, '__str__': <function Construction.__str__>, 'from_U_value': <classmethod(<function Construction.from_U_value>)>, '__dict__': <attribute '__dict__' of 'Construction' objects>, '__weakref__': <attribute '__weakref__' of 'Construction' objects>, '__annotations__': {}})

__doc__ = '\n        Represents a multi-layer building construction, including methods to calculate:\n            - Thermal resistance and U-values\n            - Thermal capacitance (ISO 13790, VDI 6007)\n            - Transfer matrix parameters for dynamic simulation\n            \n        Used for walls, roofs, floors, and internal partitions.\n    '

__module__ = 'eureca_building.construction'

__weakref__

list of weak references to the object (if defined)

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

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

Notes

This method creates an “equivalent material” with default absorptance and thickness (30 cm) based on ISO 13786 guidelines.

eureca_building.construction_dataset

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

class eureca_building.construction_dataset.ConstructionDataset

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__()

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

classmethod read_excel(file)

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

Notes

The Excel file must contain the following sheets:

• “Materials”

• “Windows”

• “Constructions”

Each sheet must follow the naming and units expected by the parser.

__dict__ = mappingproxy({'__module__': 'eureca_building.construction_dataset', '__doc__': 'This class is a class to include the list of materials,\n    construction and windows that are used in the project\n\n    Attributes\n    ----------\n    materials_dict : dict\n        Dict: dictionary with all Materials\n    constructions_dict : dict\n        Dict: dictionary with all Constructions\n    windows_dict : dict\n        Dict: dictionary with all Windows\n    ', '__init__': <function ConstructionDataset.__init__>, 'read_excel': <classmethod(<function ConstructionDataset.read_excel>)>, '__dict__': <attribute '__dict__' of 'ConstructionDataset' objects>, '__weakref__': <attribute '__weakref__' of 'ConstructionDataset' objects>, '__annotations__': {}})

__doc__ = 'This class is a class to include the list of materials,\n    construction and windows that are used in the project\n\n    Attributes\n    ----------\n    materials_dict : dict\n        Dict: dictionary with all Materials\n    constructions_dict : dict\n        Dict: dictionary with all Constructions\n    windows_dict : dict\n        Dict: dictionary with all Windows\n    '

__module__ = 'eureca_building.construction_dataset'

__weakref__

list of weak references to the object (if defined)

eureca_building.domestic_hot_water

This module includes functions to model Domestic Hot Water consumptions

eureca_building.domestic_hot_water._event_distribution(number_of_daily_events, daily_vector_distibution, number_of_days)

Generates event time steps based on a temporal probability distribution.

Parameters:

• number_of_daily_events (int) – Number of draw-off events per day.

• daily_vector_distibution (np.array) – PDF across 24-hour periods (reshaped to match model time step).

• number_of_days (int) – Number of days to simulate.

Returns:

Integer array of shape (days, events) with event time step indices.

Return type:

np.ndarray

eureca_building.domestic_hot_water.dhw_calc_calculation(volume_unit, numunits)

Generates a yearly DHW volume profile based on stochastic draw-off events.

Parameters:

• volume_unit (float) – Annual DHW volume per unit [m³/year].

• numunits (int) – Number of residential units to model.

Returns:

Hourly DHW volume demand [liters/hour], resampled to match CONFIG.time_step.

Return type:

np.ndarray

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

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, n_of_occupants=None)

__dict__ = mappingproxy({'__module__': 'eureca_building.domestic_hot_water', '__doc__': 'DomesticHotWater object\n    Class to manage all the calculations involved in the Domestic Hot Water consumption\n    ', '__init__': <function DomesticHotWater.__init__>, 'calculation_method': <property object>, 'unit': <property object>, 'schedule': <property object>, 'get_dhw_yearly_mass_flow_rate': <function DomesticHotWater.get_dhw_yearly_mass_flow_rate>, '__dict__': <attribute '__dict__' of 'DomesticHotWater' objects>, '__weakref__': <attribute '__weakref__' of 'DomesticHotWater' objects>, '__annotations__': {}})

__doc__ = 'DomesticHotWater object\n    Class to manage all the calculations involved in the Domestic Hot Water consumption\n    '

__module__ = 'eureca_building.domestic_hot_water'

__weakref__

list of weak references to the object (if defined)

property calculation_method

property unit

property schedule

get_dhw_yearly_mass_flow_rate(area, number_of_units, weather, n_of_people=None)

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

Includes standard physical properties of fluids and fuels used in energy calculations.

Dictionaries: - air_properties - water_properties - vapour_properties - fuels_pci

Also includes gravitational acceleration for use in buoyancy calculations.

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)

Bases: object

Internal Gain Class: parent class to set some common things

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

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

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

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

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

Parameters:

• args –

• kwarg –

get_loads(*args, **kwargs) → list

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]

__dict__ = mappingproxy({'__module__': 'eureca_building.internal_load', '__doc__': 'Internal Gain Class: parent class to set some common things\n    ', '__init__': <function InternalLoad.__init__>, 'nominal_value': <property object>, 'schedule': <property object>, 'fraction_to_zone': <property object>, 'fraction_latent': <property object>, 'fraction_radiant': <property object>, 'fraction_convective': <property object>, 'get_convective_load': <function InternalLoad.get_convective_load>, 'get_radiant_load': <function InternalLoad.get_radiant_load>, 'get_latent_load': <function InternalLoad.get_latent_load>, 'get_loads': <function InternalLoad.get_loads>, '__dict__': <attribute '__dict__' of 'InternalLoad' objects>, '__weakref__': <attribute '__weakref__' of 'InternalLoad' objects>, '__annotations__': {}})

__doc__ = 'Internal Gain Class: parent class to set some common things\n    '

__module__ = 'eureca_building.internal_load'

__weakref__

list of weak references to the object (if defined)

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)

Bases: InternalLoad

Models internal gains from people, including sensible and latent heat.

Supports multiple unit types (W, W/m², px, px/m²) and metabolic rate-based scaling.

__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)

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_absolute_value_nominal(area=None)

Memorizes the occupancy nominal value in W

Parameters:

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

get_convective_load(area=None)

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)

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)

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)

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

__annotations__ = {}

__doc__ = '\n    Models internal gains from people, including sensible and latent heat.\n\n    Supports multiple unit types (W, W/m², px, px/m²) and metabolic rate-based scaling.\n    '

__module__ = 'eureca_building.internal_load'

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)

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)

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

__annotations__ = {}

__doc__ = None

__module__ = 'eureca_building.internal_load'

property unit

property number_of_people

_get_absolute_value_nominal(area=None)

Memorizes the electric load nominal value in W

Parameters:

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

get_convective_load(area=None)

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)

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)

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)

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)

Bases: ElectricLoad

__annotations__ = {}

__doc__ = None

__module__ = 'eureca_building.internal_load'

__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)

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

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)

Bases: object

Represents a thermal material with conductivity, density, specific heat, and thickness.

Includes property validation based on boundary conditions, and automatic calculation of thermal capacity and resistance.

__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)

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

__annotations__ = {'cond': <class 'float'>, 'dens': <class 'float'>, 'name': <class 'str'>, 'spec_heat': <class 'float'>, 'thick': <class 'float'>}

__dict__ = mappingproxy({'__module__': 'eureca_building.material', '__annotations__': {'name': <class 'str'>, 'thick': <class 'float'>, 'cond': <class 'float'>, 'spec_heat': <class 'float'>, 'dens': <class 'float'>}, '__doc__': '\n    Represents a thermal material with conductivity, density, specific heat, and thickness.\n\n    Includes property validation based on boundary conditions, and automatic calculation of\n    thermal capacity and resistance.\n    ', 'thick': <property object>, 'cond': <property object>, 'spec_heat': <property object>, 'dens': <property object>, '__init__': <function Material.__init__>, 'thermal_absorptance': <property object>, 'calc_capacity': <function Material.calc_capacity>, 'calc_resistance': <function Material.calc_resistance>, 'calc_params': <function Material.calc_params>, '__str__': <function Material.__str__>, '__dict__': <attribute '__dict__' of 'Material' objects>, '__weakref__': <attribute '__weakref__' of 'Material' objects>})

__doc__ = '\n    Represents a thermal material with conductivity, density, specific heat, and thickness.\n\n    Includes property validation based on boundary conditions, and automatic calculation of\n    thermal capacity and resistance.\n    '

__module__ = 'eureca_building.material'

__weakref__

list of weak references to the object (if defined)

property thermal_absorptance: float

calc_capacity()

Thermal capacity calculation (thickness * density * specific_heat)

calc_resistance()

Thermal capacity calculation (thickness / conductivity)

calc_params()

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

__str__()

Return a beautiful parsed str of the properties

Returns:

A string to print properties

Return type:

str

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

Bases: object

Represents an air layer with predefined density and specific heat.

Thermal resistance is the primary property, from which conductivity is derived.

__annotations__ = {'name': <class 'str'>, 'thermal_resistance': <class 'float'>, 'thick': <class 'float'>}

__dict__ = mappingproxy({'__module__': 'eureca_building.material', '__annotations__': {'name': <class 'str'>, 'thick': <class 'float'>, 'thermal_resistance': <class 'float'>}, '__doc__': '\n    Represents an air layer with predefined density and specific heat.\n\n    Thermal resistance is the primary property, from which conductivity is derived.\n    ', 'thick': <property object>, 'thermal_resistance': <property object>, '__init__': <function AirGapMaterial.__init__>, '__str__': <function AirGapMaterial.__str__>, '__dict__': <attribute '__dict__' of 'AirGapMaterial' objects>, '__weakref__': <attribute '__weakref__' of 'AirGapMaterial' objects>})

__doc__ = '\n    Represents an air layer with predefined density and specific heat.\n\n    Thermal resistance is the primary property, from which conductivity is derived.\n    '

__module__ = 'eureca_building.material'

__weakref__

list of weak references to the object (if defined)

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

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

__str__()

Return a beautiful parsed str of the properties

Returns:

A string to print properties

Return type:

str

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)

Bases: object

Represents time-varying schedules for energy modeling (e.g., temperature, availability).

Supports validation of bounds, unit types, and generation from constant or daily profiles.

__init__(name: str, schedule_type: str, schedule: array, lower_limit=None, upper_limit=None)

property schedule_type

__dict__ = mappingproxy({'__module__': 'eureca_building.schedule', '__doc__': '\n    Represents time-varying schedules for energy modeling (e.g., temperature, availability).\n    \n    Supports validation of bounds, unit types, and generation from constant or daily profiles.\n    ', '__init__': <function Schedule.__init__>, 'schedule_type': <property object>, '_lower_limit': <property object>, '_upper_limit': <property object>, 'schedule': <property object>, 'from_daily_schedule': <classmethod(<function Schedule.from_daily_schedule>)>, 'from_constant_value': <classmethod(<function Schedule.from_constant_value>)>, '__dict__': <attribute '__dict__' of 'Schedule' objects>, '__weakref__': <attribute '__weakref__' of 'Schedule' objects>, '__annotations__': {}})

__doc__ = '\n    Represents time-varying schedules for energy modeling (e.g., temperature, availability).\n    \n    Supports validation of bounds, unit types, and generation from constant or daily profiles.\n    '

__module__ = 'eureca_building.schedule'

__weakref__

list of weak references to the object (if defined)

property _lower_limit

property _upper_limit

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 = ())

classmethod from_constant_value(name: str, schedule_type: str, value: float, lower_limit=None, upper_limit=None)

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)

Bases: object

Setpoint class

__init__(name: str, setpoint_type: str, tag: str | None = None)

property setpoint_type

__dict__ = mappingproxy({'__module__': 'eureca_building.setpoints', '__doc__': 'Setpoint class\n    ', '__init__': <function Setpoint.__init__>, 'setpoint_type': <property object>, '__dict__': <attribute '__dict__' of 'Setpoint' objects>, '__weakref__': <attribute '__weakref__' of 'Setpoint' objects>, '__annotations__': {}})

__doc__ = 'Setpoint class\n    '

__module__ = 'eureca_building.setpoints'

__weakref__

list of weak references to the object (if defined)

class eureca_building.setpoints.SetpointDualBand(name: str, setpoint_type: str, schedule_lower: Schedule, schedule_upper: Schedule, tag: str | None = None)

Bases: Setpoint

__init__(name: str, setpoint_type: str, schedule_lower: Schedule, schedule_upper: Schedule, tag: str | None = None)

__annotations__ = {}

__doc__ = None

__module__ = 'eureca_building.setpoints'

property schedule_lower

property schedule_upper

eureca_building.surface

This module includes functions to model a 3D surface

eureca_building.surface.delete_duplicates(lst)

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, h_window: float = 1.5, h_bottom: float = 1.2)

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

__warning_azimuth_subdivisions = False

__warning_height_subdivisions = False

_discharge_coefficient_nat_vent = 0.6

classmethod from_area_azimuth_height(name: str, area: float, height: float, azimuth: float, wwr=None, subdivisions_solar_calc=None, surface_type=None, construction=None, window=None, n_window_layers: int = 1)

__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, h_window: float = 1.5, h_bottom: float = 1.2)

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

• TODO (Inserire gli ultimi 3 input) –

property _vertices: tuple

property _area: float

property _wwr: float

property subdivisions_solar_calc: dict

property _azimuth_subdivisions: int

property _height_subdivisions: int

property surface_type

property construction

property window

_set_azimuth_and_zenith()

Internal method to calculate azimuth and zenith

_calc_glazed_and_opaque_areas(wwr)

Internal method to calculate glazed and opaque ares

Parameters:

wwr (float) – Window-to-wall ration. Number between 0 and 1

_define_windows_layout(n_window_layers: int = 1, h_window: float = 1.5, h_bottom: float = 1.2)

USED FOR NATURAL VENTILATION Defines the windows layout (sill height, width, number, …)

Parameters:

• n_window_layers (int, default 1) – Number of rows to consider

• TODO (Inserire i parametri mancanti della function) –

__dict__ = mappingproxy({'__module__': 'eureca_building.surface', '__doc__': 'Class surface checks the complanarity and calculates the area.\n    Then calculates the azimuth and tilt of the surface and set a surface\n    type depending on the tilt angle\n    \n    co planarity:\n        https://www.geeksforgeeks.org/program-to-check-whether-4-points-in-a-3-d-plane-are-coplanar/\n\n    the area is calculated from:\n        https://stackoverflow.com/questions/12642256/python-find-area-of-polygon-from-xyz-coordinates    \n    ', '_Surface__warning_azimuth_subdivisions': False, '_Surface__warning_height_subdivisions': False, '_discharge_coefficient_nat_vent': 0.6, 'from_area_azimuth_height': <classmethod(<function Surface.from_area_azimuth_height>)>, '__init__': <function Surface.__init__>, '_vertices': <property object>, '_area': <property object>, '_wwr': <property object>, 'subdivisions_solar_calc': <property object>, '_azimuth_subdivisions': <property object>, '_height_subdivisions': <property object>, 'surface_type': <property object>, 'construction': <property object>, 'window': <property object>, '_set_azimuth_and_zenith': <function Surface._set_azimuth_and_zenith>, '_calc_glazed_and_opaque_areas': <function Surface._calc_glazed_and_opaque_areas>, '_define_windows_layout': <function Surface._define_windows_layout>, '_set_azimuth_and_zenith_solar_radiation': <function Surface._set_azimuth_and_zenith_solar_radiation>, '_set_auto_surface_type': <function Surface._set_auto_surface_type>, 'max_height': <function Surface.max_height>, 'min_height': <function Surface.min_height>, 'get_VDI6007_surface_params': <function Surface.get_VDI6007_surface_params>, 'get_surface_external_radiative_coefficient': <function Surface.get_surface_external_radiative_coefficient>, 'check_surface_coincidence': <function Surface.check_surface_coincidence>, 'calculate_intersection_area': <function Surface.calculate_intersection_area>, 'reduce_area': <function Surface.reduce_area>, 'apply_ext_surf_coeff': <function Surface.apply_ext_surf_coeff>, '__str__': <function Surface.__str__>, '__dict__': <attribute '__dict__' of 'Surface' objects>, '__weakref__': <attribute '__weakref__' of 'Surface' objects>, '__annotations__': {}})

__doc__ = 'Class surface checks the complanarity and calculates the area.\n    Then calculates the azimuth and tilt of the surface and set a surface\n    type depending on the tilt angle\n    \n    co planarity:\n        https://www.geeksforgeeks.org/program-to-check-whether-4-points-in-a-3-d-plane-are-coplanar/\n\n    the area is calculated from:\n        https://stackoverflow.com/questions/12642256/python-find-area-of-polygon-from-xyz-coordinates    \n    '

__module__ = 'eureca_building.surface'

__weakref__

list of weak references to the object (if defined)

_set_azimuth_and_zenith_solar_radiation()

Internal method to calculate rounded azimuth and zenith

_set_auto_surface_type()

Uses tilt to autoset surface type. tilt > 150 –> GroundFloor tilt < 40 –> Roof else –> ExtWall

max_height()

Calculates max height from the most high vertex

min_height()

Calculates max height from the most low vertex

get_VDI6007_surface_params(asim=None)

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()

Returns the radiative heat exchange coefficient.

Return type:

float

check_surface_coincidence(other_surface)

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)

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)

Reduces the area of the surface by an input area

Parameters:

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

apply_ext_surf_coeff(ext_wall_correction_coef)

Reduces the area of the surface by an input correction coeffienct

Parameters:

ext_wall_correction_coef (float) – the factor to multiply [-] to the total area

__str__()

Return str(self).

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

Bases: object

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

__dict__ = mappingproxy({'__module__': 'eureca_building.surface', '__doc__': 'Class to define a surface for thermal capacity using area and surface type\n    with a specific geometry\n    ', '__init__': <function SurfaceInternalMass.__init__>, '_area': <property object>, 'surface_type': <property object>, 'construction': <property object>, 'get_VDI6007_surface_params': <function SurfaceInternalMass.get_VDI6007_surface_params>, '__dict__': <attribute '__dict__' of 'SurfaceInternalMass' objects>, '__weakref__': <attribute '__weakref__' of 'SurfaceInternalMass' objects>, '__annotations__': {}})

__doc__ = 'Class to define a surface for thermal capacity using area and surface type\n    with a specific geometry\n    '

__module__ = 'eureca_building.surface'

__weakref__

list of weak references to the object (if defined)

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

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 _area: float

property surface_type

property construction

get_VDI6007_surface_params(asim=False)

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)

Bases: object

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

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

classmethod __subclasshook__(C)

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

abstract __init__(*args, **kwargs)

abstract set_system_capacity()

abstract solve_system()

abstract property electric_consumption

abstract property gas_consumption

abstract property wood_consumption

abstract property oil_consumption

property system_type

property solar_thermal_system

set_dhw_design_capacity_tank(dhw_flow_rate, weather_file)

dhw_tank_solver(dhw_demand, weather, timestep, **kwargs)

set_solar_gain()

__abstractmethods__ = frozenset({'__init__', 'electric_consumption', 'gas_consumption', 'oil_consumption', 'set_system_capacity', 'solve_system', 'wood_consumption'})

__dict__ = mappingproxy({'__module__': 'eureca_building.systems', '__doc__': '\n    Father class for HVAC systems classes\n    Defines an interface to force inherited class to implement mandatory methods\n    ', 'gas_consumption': <property object>, 'electric_consumption': <property object>, 'wood_consumption': <property object>, 'oil_consumption': <property object>, 'pellet_consumption': 0, 'lpg_consumption': 0, 'gasoline_consumption': 0, '__subclasshook__': <classmethod(<function System.__subclasshook__>)>, '__init__': <function System.__init__>, 'set_system_capacity': <function System.set_system_capacity>, 'solve_system': <function System.solve_system>, 'system_type': <property object>, 'solar_thermal_system': <property object>, 'set_dhw_design_capacity_tank': <function System.set_dhw_design_capacity_tank>, 'dhw_tank_solver': <function System.dhw_tank_solver>, 'set_solar_gain': <function System.set_solar_gain>, '__dict__': <attribute '__dict__' of 'System' objects>, '__weakref__': <attribute '__weakref__' of 'System' objects>, '__abstractmethods__': frozenset({'oil_consumption', '__init__', 'solve_system', 'wood_consumption', 'gas_consumption', 'set_system_capacity', 'electric_consumption'}), '_abc_impl': <_abc._abc_data object>, '__annotations__': {}})

__doc__ = '\n    Father class for HVAC systems classes\n    Defines an interface to force inherited class to implement mandatory methods\n    '

__module__ = 'eureca_building.systems'

__weakref__

list of weak references to the object (if defined)

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.IdealLoad(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

__init__(*args, **kwargs)

IdealLoad init method. No input needed

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

Set system capacity method.

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int, *args)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = 'Class IdealLoad is for the ideal  zone balance. This class passes all methods.\n    '

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.CondensingBoiler(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

__init__(*args, **kwargs)

init method. Set some attributes for the method are initialized

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

Sets system design power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, dhw_flow, weather, t, T_int, RH_int)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

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

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.TraditionalBoiler(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

__init__(*args, **kwargs)

init method. Set some attributes for the method

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

Sets system design power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, dhw_flow, weather, t, T_int, RH_int)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

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

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.SplitAirCooler(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

__init__(*args, **kwargs)

init method. Set some attributes for the method

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

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

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.ChillerAirtoWater(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

__init__(*args, **kwargs)

init method. Set some attributes for the method

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

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

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.SplitAirConditioner(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

__init__(*args, **kwargs)

init method. Set some attributes for the method

Parameters:

• args –

• kwargs –

set_system_capacity(design_power, weather)

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

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int)

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 [%]

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = 'SplitAirConditioner class\n\n    This method considers a generic Split Air Conditioner as the cooling system\n    of the entire building following two documents of literature\n\n    Berend Jan Christiaan van Putten, Nariman Mahdavi, Julio H. Braslavsky,\n    An Analytical Model for Demand Response of Variable-Speed Air Conditioners,\n    IFAC-PapersOnLine,\n    Volume 51, Issue 28,\n    2018,\n    Pages 426-431,\n    ISSN 2405-8963,\n    https://doi.org/10.1016/j.ifacol.2018.11.740.\n    (https://www.sciencedirect.com/science/article/pii/S2405896318334608)\n\n    https://ieeexplore.ieee.org/document/7515217\n    N. Mahdavi, J. H. Braslavsky and C. Perfumo,\n    "Mapping the Effect of Ambient Temperature on the Power Demand of Populations of Air Conditioners,"\n    in IEEE Transactions on Smart Grid, vol. 9, no. 3, pp. 1540-1550, May 2018,\n    doi: 10.1109/TSG.2016.2592522.\n    '

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.Heating_EN15316(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

__init__(*args, **kwargs)

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)

‘Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, dhw_flow, weather, t, T_int, RH_int, **kwargs)

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 [%]

• kwargs –

solve_quasi_steady_state(heat_flow, dhw_flow)

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

Parameters:

• heat_flow (float) – required power [Wh]

• dhw_flow (float) – required power [Wh]

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = 'Class Heating_EN15316. This method considers a generic heating system as the heating system\n    of the entire building following EN 15316.\n    '

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.Cooling_EN15316(*args, **kwargs)

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

coal_consumption = 0

DH_consumption = 0

__init__(*args, **kwargs)

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)

‘Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int)

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 [%]

solve_quasi_steady_state(heat_flow)

This method allows to calculate the system power for each month

Parameters:

heat_flow (float) – required power [Wh]

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = 'Class Cooling_EN15316. This method considers a generic cooling system as the heating system\n    of the entire building following EN 15316.\n    '

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.HP_Staffell(*args, **kwargs)

Bases: System

Class Heating HP Staffel.

gas_consumption = 0

electric_consumption = 0

wood_consumption = 0

oil_consumption = 0

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

lpg_consumption = 0

gasoline_consumption = 0

__init__(*args, **kwargs)

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)

solve_system(heat_flow, dhw_flow, weather, t, T_int, RH_int, **kwargs)

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 [%]

• kwargs –

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = 'Class Heating HP Staffel.\n    '

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.HeatingFromParams(*args, **kwargs)

Bases: System

gas_consumption = 0

electric_consumption = 0

wood_consumption = 0

oil_consumption = 0

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

__init__(*args, **kwargs)

set_system_capacity(design_power, weather)

‘Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, dhw_flow, weather, t, T_int, RH_int)

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 [%]

solve_quasi_steady_state(heat_flow, dhw_flow)

This method allows to calculate the system power for each month

Parameters:

• heat_flow (float) – required power [Wh]

• dhw_flow (float) – required power [Wh]

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = None

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

class eureca_building.systems.CoolingFromParams(*args, **kwargs)

Bases: System

gas_consumption = 0

electric_consumption = 0

wood_consumption = 0

oil_consumption = 0

coal_consumption = 0

DH_consumption = 0

pellet_consumption = 0

__init__(*args, **kwargs)

__abstractmethods__ = frozenset({})

__annotations__ = {}

__doc__ = None

__module__ = 'eureca_building.systems'

_abc_impl = <_abc._abc_data object>

set_system_capacity(design_power, weather)

‘Choice of system size based on estimated nominal Power

Parameters:

• design_power (float) – Design Heating power [W]

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

solve_system(heat_flow, weather, t, T_int, RH_int)

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 [%]

solve_quasi_steady_state(heat_flow)

This method allows to calculate the system power for each month

Parameters:

heat_flow (float) – required power [Wh]

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)

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)

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.

• number_of_units (int, default 1) – number of units/dwellings in the thermal zone (for DHW)

• NV_ACH_limit (float, default None) – maximum accepted ACH for the thermal zone in Vol/h. If None, leave None.

property _surface_list: float

property _net_floor_area: float

property _volume: float

property number_of_units: int

property _air_thermal_capacity: float

add_temperature_setpoint(setpoint, mode='air')

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)

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)

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)

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()

Extracts internal load components from the thermal zone.

Returns:

Dictionary with keys: ‘convective [W]’, ‘radiative [W]’, ‘latent [kg_vap/s]’, ‘electric [W]’ Each mapped to a NumPy array of length equal to CONFIG.number_of_time_steps_year.

Return type:

dict

add_infiltration(*infiltration)

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)

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_natural_ventilation(natural_ventilation, weather)

Function to associate a natural ventilation object to the thermal zone

Parameters:

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

add_air_handling_unit(ahu, weather)

Function to associate an air_handling_unit object to the thermal zone

Parameters:

• ahu (eureca_building.air_handling_unit.AirHandlingUnit) – AirHandlingUnit object

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

property air_handling_unit: AirHandlingUnit

__dict__ = mappingproxy({'__module__': 'eureca_building.thermal_zone', '__doc__': 'Thermal zone class. Manages all the models and time step solution of the sensible and latent systems\n    ', '__init__': <function ThermalZone.__init__>, '_surface_list': <property object>, '_net_floor_area': <property object>, '_volume': <property object>, 'number_of_units': <property object>, '_air_thermal_capacity': <property object>, 'add_temperature_setpoint': <function ThermalZone.add_temperature_setpoint>, 'temperature_setpoint': <property object>, 'temperature_setpoint_mode': <property object>, 'add_humidity_setpoint': <function ThermalZone.add_humidity_setpoint>, 'humidity_setpoint': <property object>, 'humidity_setpoint_mode': <property object>, 'get_specific_humidity': <staticmethod(<function ThermalZone.get_specific_humidity>)>, 'add_internal_load': <function ThermalZone.add_internal_load>, 'extract_convective_radiative_latent_electric_load': <function ThermalZone.extract_convective_radiative_latent_electric_load>, 'add_infiltration': <function ThermalZone.add_infiltration>, 'calc_infiltration': <function ThermalZone.calc_infiltration>, 'add_natural_ventilation': <function ThermalZone.add_natural_ventilation>, 'add_air_handling_unit': <function ThermalZone.add_air_handling_unit>, 'air_handling_unit': <property object>, 'add_domestic_hot_water': <function ThermalZone.add_domestic_hot_water>, '_ISO13790_params': <function ThermalZone._ISO13790_params>, 'print_ISO13790_params': <function ThermalZone.print_ISO13790_params>, '_VDI6007_params': <function ThermalZone._VDI6007_params>, 'print_VDI6007_params': <function ThermalZone.print_VDI6007_params>, 'calculate_zone_loads_ISO13790': <function ThermalZone.calculate_zone_loads_ISO13790>, 'calculate_zone_loads_VDI6007': <function ThermalZone.calculate_zone_loads_VDI6007>, 'sensible_balance_1C': <function ThermalZone.sensible_balance_1C>, 'sensible_balance_2C': <function ThermalZone.sensible_balance_2C>, 'latent_balance': <function ThermalZone.latent_balance>, 'reset_init_values': <function ThermalZone.reset_init_values>, 'reset_init_values_VDI': <function ThermalZone.reset_init_values_VDI>, 'solve_timestep': <function ThermalZone.solve_timestep>, 'solve_quasisteadystate_method': <function ThermalZone.solve_quasisteadystate_method>, 'design_heating_load': <function ThermalZone.design_heating_load>, 'design_sensible_cooling_load': <function ThermalZone.design_sensible_cooling_load>, 'get_zone_info': <function ThermalZone.get_zone_info>, '__dict__': <attribute '__dict__' of 'ThermalZone' objects>, '__weakref__': <attribute '__weakref__' of 'ThermalZone' objects>, '__annotations__': {}})

__doc__ = 'Thermal zone class. Manages all the models and time step solution of the sensible and latent systems\n    '

__module__ = 'eureca_building.thermal_zone'

__weakref__

list of weak references to the object (if defined)

add_domestic_hot_water(weather_obj, *dhw_obj)

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

Parameters:

• dhw_obj (eureca_building.domestic_hot_water.DomesticHotWater) – DomesticHotWater object

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

_ISO13790_params()

Calculates the thermal zone parameters of the ISO 13790 it does not require input

Htr_is Htr_w Htr_ms Htr_emCm DenAm Atot Htr_op UA_tot

print_ISO13790_params()

Just a beuty print of ISO 13790 parameters

Return type:

str

_VDI6007_params()

Calculates the thermal zone parameters of the VDI 6007 it does not require input

Araum_tot Aaw_tot Araum_opaque Aaw_opaque R1AW, R1IW, C1AW, C1IW RgesAW RrestAW RalphaStarIL, RalphaStarAW, RalphaStarIW UA_tot Htr_op Htr_w

print_VDI6007_params()

Just a beuty print of VDI6007 parameters

Return type:

str

calculate_zone_loads_ISO13790(weather)

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)

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)

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)

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)

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)

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()

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')

Solves the thermal zone t - time step

Parameters:

• t (int) – timestep of the simulation

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

• model (str, default "2C") – ‘1C’ model or ‘2C’ model

solve_quasisteadystate_method(weather)

design_heating_load(weather)

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')

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:

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

• model (str, default "2C") – ‘1C’ model or ‘2C’ model

get_zone_info()

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)

Solves the neutral pressure plane height for natural ventilation using input coefficients.

Parameters:

• x (float) – Height guess for the neutral plane.

• data (tuple) – Coefficients for pressure difference equation.

Returns:

Residual of pressure balance equation to be minimized.

Return type:

float

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

Bases: object

Ventilation class

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

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_absolute_value_nominal(area=None, volume=None)

Returns ventilation nominal value 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:

Sets self.nominal_value_absolute for later use.

Return type:

None

get_air_flow_rate(area=None, volume=None) → array

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

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

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

Parameters:

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

• args (list) – additional args

• kwargs (dict) – additional kwargs

Returns:

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

Return type:

tuple

__dict__ = mappingproxy({'__module__': 'eureca_building.ventilation', '__doc__': 'Ventilation class\n    ', '__init__': <function Ventilation.__init__>, 'nominal_value': <property object>, 'schedule': <property object>, 'unit': <property object>, '_get_absolute_value_nominal': <function Ventilation._get_absolute_value_nominal>, 'get_air_flow_rate': <function Ventilation.get_air_flow_rate>, 'get_vapour_flow_rate': <function Ventilation.get_vapour_flow_rate>, 'get_flow_rate': <function Ventilation.get_flow_rate>, '__dict__': <attribute '__dict__' of 'Ventilation' objects>, '__weakref__': <attribute '__weakref__' of 'Ventilation' objects>, '__annotations__': {}})

__doc__ = 'Ventilation class\n    '

__module__ = 'eureca_building.ventilation'

__weakref__

list of weak references to the object (if defined)

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

Bases: Ventilation

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

__annotations__ = {}

__doc__ = 'This is just an inherited version of the Ventilation class, without any change\n    '

__module__ = 'eureca_building.ventilation'

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, vol_flow_limit: float | None = None)

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, vol_flow_limit: float | None = None)

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

• vol_flow_limit (float) – Limit to natural vent in m3/s

property schedule

property unit

_get_absolute_value_nominal()

Returns natural ventilation nominal value in kg/s. Overrides the parent class method

Parameters:

• args –

• kwargs –

__annotations__ = {}

__doc__ = 'Inheritaded from the Ventilation class\n    '

__module__ = 'eureca_building.ventilation'

get_air_flow_rate()

Not implemented for Natural Ventilation

get_vapour_flow_rate()

Not implemented for Natural Ventilation

get_flow_rate()

Not implemented for Natural Ventilation

_get_windows_opening() → array

Calc the windows opening from the input schedule in 0-1 range

Returns:

Wiondow opening schedule [0-1]

Return type:

numpy.array

define_pressure_coef(weather, surfaces_with_opening)

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)

TODO : Per Giacomo compila la documentazione

Parameters:

• ts (int) – time step of simulation

• t_zone (float) – zone temperature [°C]

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

• vol_flow_limit (float) – Upper limit for the NV flow rate [m3/s]

Returns:

NV air flow rate [m3/s]

Return type:

float

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

Bases: Ventilation

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

__annotations__ = {}

__doc__ = 'The same as Natural/Ventilation object but different check on units\n    '

__module__ = 'eureca_building.ventilation'

property unit

_get_absolute_value_nominal(area=0, volume=0)

Calcs ventilation nominal value in kg/s. This method overrides the parent class method

Parameters:

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

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

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], replacing_data=None)

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], replacing_data=None)

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)

Returns:

Populates weather data attributes (hourly_data, general_data, monthly_data).

Return type:

None

irradiances_calculation()

” Calculates solar position and irradiance components across directions and stores them in hourly_data.

Return type:

None

classmethod from_pvgis(lat: float, long: float, country=None, city=None, 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])

monthly_statistics(printer=True)

replace_weather_data(weather_data)

Replace This method replaces the existing input weather data (from epw) with data coming from external dataset

Parameters:

weather_data (pandas.DataFrame) – pandas DataFrame with the iweather data that will replace the existing epw data

Return type:

None.

__dict__ = mappingproxy({'__module__': 'eureca_building.weather', '__doc__': 'This class is a container for all weather data.\n    It processes the epw file to extract arrays of temperature, wind, humidity etc......\n    ', '__init__': <function WeatherFile.__init__>, 'irradiances_calculation': <function WeatherFile.irradiances_calculation>, 'from_pvgis': <classmethod(<function WeatherFile.from_pvgis>)>, 'monthly_statistics': <function WeatherFile.monthly_statistics>, 'replace_weather_data': <function WeatherFile.replace_weather_data>, '__dict__': <attribute '__dict__' of 'WeatherFile' objects>, '__weakref__': <attribute '__weakref__' of 'WeatherFile' objects>, '__annotations__': {}})

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

__module__ = 'eureca_building.weather'

__weakref__

list of weak references to the object (if defined)

eureca_building.weather._TskyCalc(T_ext, T_dp, P_, n_opaque, time_steps)

Apparent sky temperature calculation procedure Martin Berdhal model used by TRNSYS

Parameters:

• T_ext (numpy.array) – External Temperature [°C]

• T_dp (pandas.DataFrame) – External dew point temperature [°C]. It must be a pandas.DataFrame column

• P (pandas.DataFrame) – External pressure [Pa]. It must be a pandas.DataFrame column

• n_opaque (pandas.DataFrame) – Opaque sky covering [-]. It must be a pandas.DataFrame column

Returns:

Average temperature difference between External air temperature and Apparent sky temperature [°C]

Return type:

float

eureca_building.weather._get_irradiance(weather_obj, surf_tilt, surf_az)

function from pvlib to calculate irradiance on a specific surface https://pvlib-python.readthedocs.io/en/stable/auto_examples/plot_ghi_transposition.html#sphx-glr-auto-examples-plot-ghi-transposition-py

Parameters:

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

• surf_tilt (float) – tilt of the surface

• surf_az (float) – azimuth of the surface

Returns:

pandas DataFrame with the irradiances on the surface

Return type:

pandas.DataFrame

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)

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)

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

__dict__ = mappingproxy({'__module__': 'eureca_building.window', '__doc__': 'Defines the simple window model with all its characteristics\n    and apply the simple glazing model to estimates the curve of SHGC(theta)\n    ', '__init__': <function SimpleWindow.__init__>, 'u_value': <property object>, 'solar_heat_gain_coef': <property object>, 'visible_transmittance': <property object>, 'frame_factor': <property object>, 'shading_coef_int': <property object>, 'shading_coef_ext': <property object>, 'simpleGlazingModel': <function SimpleWindow.simpleGlazingModel>, '__str__': <function SimpleWindow.__str__>, '__dict__': <attribute '__dict__' of 'SimpleWindow' objects>, '__weakref__': <attribute '__weakref__' of 'SimpleWindow' objects>, '__annotations__': {}})

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

__module__ = 'eureca_building.window'

__weakref__

list of weak references to the object (if defined)

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()

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

__str__()

Just a beauty print of the properties

Return type:

str

Module contents