def generate_archetype(self):
"""Generates an office building.
With given values, this class generates an office archetype building
according to TEASER requirements.
"""
# help area for the correct building area setting while using typeBldgs
self.thermal_zones = None
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
# create zones with their corresponding area, name and usage
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.area = type_bldg_area * value[0]
zone.name = key
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1], data_class=self.parent.data)
zone.use_conditions = use_cond
# statistical estimation of the facade
self._est_outer_wall_area = (self.est_factor_wall_area *
type_bldg_area**self.est_exponent_wall)
self._est_win_area = (self.est_factor_win_area *
type_bldg_area**self.est_exponent_win)
self._est_roof_area = (type_bldg_area /
self.number_of_floors) * self.gross_factor
self._est_floor_area = (type_bldg_area /
self.number_of_floors) * self.gross_factor
# manipulation of wall according to facade design
# (received from window_layout)
self._est_facade_area = self._est_outer_wall_area + self._est_win_area
if not self.window_layout == 0:
self._est_outer_wall_area = self._est_facade_area * self.corr_factor_wall
self._est_win_area = self._est_facade_area * self.corr_factor_win
else:
pass
# set the facade area to the four orientations
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180:
self.outer_area[value[1]] = self._est_outer_wall_area * (
self._est_length /
(2 * self._est_width + 2 * self._est_length))
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area * (
self._est_width /
(2 * self._est_width + 2 * self._est_length))
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area * (
self._est_length /
(2 * self._est_width + 2 * self._est_length))
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area * (
self._est_width /
(2 * self._est_width + 2 * self._est_length))
"""
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime.
"""
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(
self.year_of_construction,
"Kunststofffenster, "
"Isolierverglasung",
data_class=self.parent.data,
)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data,
)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def generate_archetype(self):
"""Generates a SingleFamilyHouse archetype buildings
With given values, this function generates an archetype building for
Tabula Single Family House.
"""
self.thermal_zones = None
self._check_year_of_construction()
# help area for the correct building area setting while using typeBldgs
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
for key, value in self.zone_area_factors.items():
zone = ThermalZone(parent=self)
zone.name = key
zone.area = type_bldg_area * value[0]
use_cond = UseCond(parent=zone)
use_cond.load_use_conditions(zone_usage=value[1])
zone.use_conditions = use_cond
zone.use_conditions.with_ahu = False
zone.use_conditions.persons *= zone.area * 0.01
zone.use_conditions.machines *= zone.area * 0.01
if self.facade_estimation_factors[self.building_age_group]['ow1'] != 0:
for key, value in self._outer_wall_names_1.items():
for zone in self.thermal_zones:
outer_wall = OuterWall(zone)
outer_wall.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_1,
data_class=self.parent.data)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
outer_wall.area = ((self.facade_estimation_factors[
self.building_age_group]['ow1'] * type_bldg_area) /
len(self._outer_wall_names_1))
if self.facade_estimation_factors[self.building_age_group]['ow2'] != 0:
for key, value in self._outer_wall_names_2.items():
for zone in self.thermal_zones:
outer_wall = OuterWall(zone)
outer_wall.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_2,
data_class=self.parent.data)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
outer_wall.area = ((self.facade_estimation_factors[
self.building_age_group]['ow2'] * type_bldg_area) /
len(self._outer_wall_names_2))
if self.facade_estimation_factors[
self.building_age_group]['win1'] != 0:
for key, value in self.window_names_1.items():
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(
self.year_of_construction,
construction=self._construction_type_1,
data_class=self.parent.data)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
window.area = ((self.facade_estimation_factors[
self.building_age_group]['win1'] * type_bldg_area) /
len(self.window_names_1))
if self.facade_estimation_factors[
self.building_age_group]['win2'] != 0:
for key, value in self.window_names_2.items():
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(
self.year_of_construction,
construction=self._construction_type_2,
data_class=self.parent.data)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
window.area = ((self.facade_estimation_factors[
self.building_age_group]['win2'] * type_bldg_area) /
len(self.window_names_2))
if self.facade_estimation_factors[self.building_age_group]['gf1'] != 0:
for key, value in self.ground_floor_names_1.items():
for zone in self.thermal_zones:
gf = GroundFloor(zone)
gf.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_1,
data_class=self.parent.data)
gf.name = key
gf.tilt = value[0]
gf.orientation = value[1]
gf.area = ((self.facade_estimation_factors[
self.building_age_group]['gf1'] * type_bldg_area) /
len(self.ground_floor_names_1))
if self.facade_estimation_factors[self.building_age_group]['gf2'] != 0:
for key, value in self.ground_floor_names_2.items():
for zone in self.thermal_zones:
gf = GroundFloor(zone)
gf.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_2,
data_class=self.parent.data)
gf.name = key
gf.tilt = value[0]
gf.orientation = value[1]
gf.area = ((self.facade_estimation_factors[
self.building_age_group]['gf2'] * type_bldg_area) /
len(self.ground_floor_names_2))
if self.facade_estimation_factors[self.building_age_group]['rt1'] != 0:
for key, value in self.roof_names_1.items():
for zone in self.thermal_zones:
rt = Rooftop(zone)
rt.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_1,
data_class=self.parent.data)
rt.name = key
rt.tilt = value[0]
rt.orientation = value[1]
rt.area = ((self.facade_estimation_factors[
self.building_age_group]['rt1'] * type_bldg_area) /
len(self.roof_names_1))
if self.facade_estimation_factors[self.building_age_group]['rt2'] != 0:
for key, value in self.roof_names_2.items():
for zone in self.thermal_zones:
rt = Rooftop(zone)
rt.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_2,
data_class=self.parent.data)
rt.name = key
rt.tilt = value[0]
rt.orientation = value[1]
rt.area = ((self.facade_estimation_factors[
self.building_age_group]['rt2'] * type_bldg_area) /
len(self.roof_names_2))
if self.facade_estimation_factors[
self.building_age_group]['door'] != 0:
for key, value in self.door_names.items():
for zone in self.thermal_zones:
door = Door(zone)
door.load_type_element(
year=self.year_of_construction,
construction=self._construction_type_1,
data_class=self.parent.data)
door.name = key
door.tilt = value[0]
door.orientation = value[1]
door.area = ((self.facade_estimation_factors[
self.building_age_group]['door'] * type_bldg_area) /
len(self.door_names))
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(year=self.year_of_construction,
construction="tabula_standard",
data_class=self.parent.data)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(year=self.year_of_construction,
construction="tabula_standard",
data_class=self.parent.data)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(year=self.year_of_construction,
construction="tabula_standard",
data_class=self.parent.data)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def generate_archetype(self):
"""Generates a SingleFamilyDwelling building.
With given values, this class generates a archetype building for
single family dwellings according to TEASER requirements
"""
# help area for the correct building area setting while using typeBldgs
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
self._number_of_heated_floors = self._est_factor_heated_cellar + \
self.number_of_floors + self.est_living_area_factor \
* self._est_factor_heated_attic
self._living_area_per_floor = type_bldg_area / \
self._number_of_heated_floors
self._est_ground_floor_area = self.est_bottom_building_closure * \
self._living_area_per_floor
self._est_roof_area = self.est_upper_building_closure * \
self._est_factor_dormer * self._est_area_per_floor * \
self._living_area_per_floor
self._top_floor_area = self._est_area_per_roof * \
self._living_area_per_floor
if self._est_roof_area == 0:
self._est_roof_area = self._top_floor_area
self._est_facade_area = self._est_facade_to_floor_area * \
self._living_area_per_floor + self._est_extra_floor_area
self._est_win_area = self.est_factor_win_area * type_bldg_area
self._est_cellar_wall_area = self.est_factor_cellar_area * \
self._est_factor_heated_cellar * self._est_facade_area
self._est_outer_wall_area = (self._number_of_heated_floors *
self._est_facade_area) - \
self._est_cellar_wall_area - \
self._est_win_area
# self._est_factor_volume = type_bldg_area * 2.5
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.name = key
zone.area = type_bldg_area * value[0]
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1], data_class=self.parent.data)
zone.use_conditions = use_cond
zone.use_conditions.with_ahu = False
zone.use_conditions.persons *= zone.area * 0.01
zone.use_conditions.machines *= zone.area * 0.01
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180.0:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
'''
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime
'''
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(self.year_of_construction,
"Kunststofffenster, "
"Isolierverglasung",
data_class=self.parent.data)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_ground_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
# zone.inner_walls.append(inner_wall)
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
# zone.inner_walls.append(floor)
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def import_building_from_excel(project, building_name, construction_age,
path_to_excel, sheet_names):
"""
Import building data from excel, convert it via the respective zoning and feed it to teasers logic classes.
Pay attention to hard coded parts, which are marked.
Parameters
----------
project: Project()
TEASER instance of Project
building_name: str
name of building to be set in the project
construction_age: int [y]
construction age of the building
path_to_excel: str
path to excel file to be imported
sheet_names: str or list
sheet names which shall be imported
return data: pandas.DataFrame
zoned DataFrame which is finally used to parametrize the teaser classes
return project: Project()
TEASER instance of Project filled with the imported building data
"""
def warn_constructiontype(element):
"""Generic warning function"""
if element.construction_type is None:
warnings.warn(
'In zone "%s" the %s construction "%s" could not be loaded from the TypeBuildingElements.json, '
"an error will occur due to missing data for calculation."
"Check for spelling and the correct combination of building age and construction type."
"Here is the list of faulty entries:\n%s"
"\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx"
% (
group["zone"].iloc[0],
element.name,
group["OuterWallConstruction"].iloc[0],
group,
))
bldg = Building(parent=project)
bldg.name = building_name
bldg.year_of_construction = construction_age
bldg.with_ahu = True # HardCodedInput
if bldg.with_ahu is True:
bldg.central_ahu.heat_recovery = True # HardCodedInput
bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput
bldg.central_ahu.temperature_profile = 25 * [273.15 + 18
] # HardCodedInput
bldg.central_ahu.min_relative_humidity_profile = 25 * [
0
] # HardCodedInput
bldg.central_ahu.max_relative_humidity_profile = 25 * [
1
] # HardCodedInput
bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput
# Parameters that need hard coding in teasers logic classes
# 1. "use_set_back" needs hard coding at aixlib.py in the init; defines
# if the in the useconditions stated
# heating_time with the respective set_back_temp should be applied.
# use_set_back = false -> all hours of the day
# have same set_temp_heat actual value: use_set_back = Check your current version!
# 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text
# file
# "teaser / data / output / modelicatemplate / AixLib /
# AixLib_ThermalZoneRecord_TwoElement"
# actual changes: Check your current version!
# Parameters to be set for each and every zone (#HardCodedInput)
# -----------------------------
out_wall_tilt = 90
window_tilt = 90
ground_floor_tilt = 0
floor_tilt = 0
ceiling_tilt = 0
rooftop_tilt = 0
ground_floor_orientation = -2
floor_orientation = -2
rooftop_orientation = -1
ceiling_orientation = -1
# -----------------------------
# load_building_data from excel_to_pandas DataFrame:
data = import_data(path_to_excel, sheet_names)
# informative print
usage_types = get_list_of_present_entries(data["UsageType"])
print("List of present usage_types in the original Data set: \n%s" %
usage_types)
# define the zoning methodology/function
data = zoning_example(data)
# informative print
usage_types = get_list_of_present_entries(data["Zone"])
print("List of zones after the zoning is applied: \n%s" % usage_types)
# aggregate all rooms of each zone and for each set general parameter,
# boundary conditions
# and parameter regarding the building physics
zones = data.groupby(["Zone"])
for name, zone in zones:
# Block: Thermal zone (general parameter)
tz = ThermalZone(parent=bldg)
tz.name = str(name)
tz.area = zone["NetArea[m²]"].sum()
# room vice calculation of volume plus summing those
tz.volume = (np.array(zone["NetArea[m²]"]) *
np.array(zone["HeatedRoomHeight[m]"])).sum()
# Block: Boundary Conditions
# load UsageOperationTime, Lighting, RoomClimate and InternalGains
# from the "UseCondition.json"
tz.use_conditions = UseConditions(parent=tz)
tz.use_conditions.load_use_conditions(zone["Zone"].iloc[0],
project.data)
# Block: Building Physics
# Grouping by orientation and construction type
# aggregating and feeding to the teaser logic classes
grouped = zone.groupby(
["OuterWallOrientation[°]", "OuterWallConstruction"])
for name, group in grouped:
# looping through a groupby object automatically discards the
# groups where one of the attributes is nan
# additionally check for strings, since the value must be of type
# int or float
if not isinstance(group["OuterWallOrientation[°]"].iloc[0], str):
out_wall = OuterWall(parent=tz)
out_wall.name = (
"outer_wall_" +
str(int(group["OuterWallOrientation[°]"].iloc[0])) + "_" +
str(group["OuterWallConstruction"].iloc[0]))
out_wall.area = group["OuterWallArea[m²]"].sum()
out_wall.tilt = out_wall_tilt
out_wall.orientation = group["OuterWallOrientation[°]"].iloc[0]
# load wall properties from "TypeBuildingElements.json"
out_wall.load_type_element(
year=bldg.year_of_construction,
construction=group["OuterWallConstruction"].iloc[0],
)
warn_constructiontype(out_wall)
else:
warnings.warn(
'In zone "%s" the OuterWallOrientation "%s" is '
"neither float nor int, "
"hence this building element is not added.\nHere is the "
"list of faulty entries:\n%s"
"\n These entries can easily be found checking the stated "
"index in the produced ZonedInput.xlsx" % (
group["Zone"].iloc[0],
group["OuterWallOrientation[°]"].iloc[0],
group,
))
grouped = zone.groupby(["WindowOrientation[°]", "WindowConstruction"])
for name, group in grouped:
# looping through a groupby object automatically discards the
# groups where one of the attributes is nan
# additionally check for strings, since the value must be of type
# int or float
if not isinstance(group["OuterWallOrientation[°]"].iloc[0], str):
window = Window(parent=tz)
window.name = (
"window_" +
str(int(group["WindowOrientation[°]"].iloc[0])) + "_" +
str(group["WindowConstruction"].iloc[0]))
window.area = group["WindowArea[m²]"].sum()
window.tilt = window_tilt
window.orientation = group["WindowOrientation[°]"].iloc[0]
# load wall properties from "TypeBuildingElements.json"
window.load_type_element(
year=bldg.year_of_construction,
construction=group["WindowConstruction"].iloc[0],
)
warn_constructiontype(window)
else:
warnings.warn(
'In zone "%s" the window orientation "%s" is neither '
"float nor int, "
"hence this building element is not added. Here is the "
"list of faulty entries:\n%s"
"\nThese entries can easily be found checking the stated "
"index in the produced ZonedInput.xlsx" % (
group["Zone"].iloc[0],
group["WindowOrientation[°]"].iloc[0],
group,
))
grouped = zone.groupby(["IsGroundFloor", "FloorConstruction"])
for name, group in grouped:
if group["NetArea[m²]"].sum() != 0: # to avoid devision by 0
if group["IsGroundFloor"].iloc[0] == 1:
ground_floor = GroundFloor(parent=tz)
ground_floor.name = "ground_floor" + str(
group["FloorConstruction"].iloc[0])
ground_floor.area = group["NetArea[m²]"].sum()
ground_floor.tilt = ground_floor_tilt
ground_floor.orientation = ground_floor_orientation
# load wall properties from "TypeBuildingElements.json"
ground_floor.load_type_element(
year=bldg.year_of_construction,
construction=group["FloorConstruction"].iloc[0],
)
warn_constructiontype(ground_floor)
elif group["IsGroundFloor"].iloc[0] == 0:
floor = Floor(parent=tz)
floor.name = "floor" + str(
group["FloorConstruction"].iloc[0])
floor.area = group["NetArea[m²]"].sum() / 2 # only half of
# the floor belongs to this story
floor.tilt = floor_tilt
floor.orientation = floor_orientation
# load wall properties from "TypeBuildingElements.json"
floor.load_type_element(
year=bldg.year_of_construction,
construction=group["FloorConstruction"].iloc[0],
)
warn_constructiontype(floor)
else:
warnings.warn(
"Values for IsGroundFloor have to be either 0 or 1, "
"for no or yes respectively")
else:
warnings.warn(
'zone "%s" with IsGroundFloor "%s" and construction '
'type "%s" '
"has no floor nor groundfloor, since the area equals 0." %
(
group["Zone"].iloc[0],
group["IsGroundFloor"].iloc[0],
group["FloorConstruction"].iloc[0],
))
grouped = zone.groupby(["IsRooftop", "CeilingConstruction"])
for name, group in grouped:
if group["NetArea[m²]"].sum() != 0: # to avoid devision by 0
if group["IsRooftop"].iloc[0] == 1:
rooftop = Rooftop(parent=tz)
rooftop.name = "rooftop" + str(
group["CeilingConstruction"].iloc[0])
rooftop.area = group["NetArea[m²]"].sum(
) # sum up area of respective
# rooftop parts
rooftop.tilt = rooftop_tilt
rooftop.orientation = rooftop_orientation
# load wall properties from "TypeBuildingElements.json"
rooftop.load_type_element(
year=bldg.year_of_construction,
construction=group["CeilingConstruction"].iloc[0],
)
warn_constructiontype(rooftop)
elif group["IsRooftop"].iloc[0] == 0:
ceiling = Ceiling(parent=tz)
ceiling.name = "ceiling" + str(
group["CeilingConstruction"].iloc[0])
ceiling.area = group["NetArea[m²]"].sum() / 2 # only half
# of the ceiling belongs to a story,
# the other half to the above
ceiling.tilt = ceiling_tilt
ceiling.orientation = ceiling_orientation
# load wall properties from "TypeBuildingElements.json"
ceiling.load_type_element(
year=bldg.year_of_construction,
construction=group["CeilingConstruction"].iloc[0],
)
warn_constructiontype(ceiling)
else:
warnings.warn(
"Values for IsRooftop have to be either 0 or 1, "
"for no or yes respectively")
else:
warnings.warn(
'zone "%s" with IsRooftop "%s" and construction type '
'"%s" '
"has no ceiling nor rooftop, since the area equals 0." % (
group["Zone"].iloc[0],
group["IsRooftop"].iloc[0],
group["CeilingConstruction"].iloc[0],
))
grouped = zone.groupby(["InnerWallConstruction"])
for name, group in grouped:
if group["InnerWallArea[m²]"].sum() != 0: # to avoid devision by 0
in_wall = InnerWall(parent=tz)
in_wall.name = "inner_wall" + str(
group["InnerWallConstruction"].iloc[0])
in_wall.area = group["InnerWallArea[m²]"].sum() / 2 # only
# half of the wall belongs to each room,
# the other half to the adjacent
# load wall properties from "TypeBuildingElements.json"
in_wall.load_type_element(
year=bldg.year_of_construction,
construction=group["InnerWallConstruction"].iloc[0],
)
warn_constructiontype(in_wall)
else:
warnings.warn(
'zone "%s" with inner wall construction "%s" has no '
"inner walls, since area = 0." %
(group["Zone"].iloc[0], group["InnerWallConstructio"
"n"].iloc[0]))
# Block: AHU and infiltration #Attention hard coding
# set the supply volume flow of the AHU per zone
ahu_dict = {
"Bedroom": [15.778, 15.778],
"Corridorsinthegeneralcarearea": [5.2941, 5.2941],
"Examinationortreatmentroom": [15.743, 15.743],
"MeetingConferenceseminar": [16.036, 16.036],
"Stocktechnicalequipmentarchives": [20.484, 20.484],
"WCandsanitaryroomsinnonresidentialbuildings": [27.692, 27.692],
}
_i = 0
for key in ahu_dict:
if tz.name == key:
tz.use_conditions.min_ahu = ahu_dict[key][0]
tz.use_conditions.max_ahu = ahu_dict[key][1]
_i = 1
if _i == 0:
warnings.warn(
"The zone %s could not be found in your ahu_dict. Hence, "
"no AHU flow is defined. The default value is "
"0 (min_ahu = 0; max_ahu=0" % tz.name)
return project, data
def example_create_building():
'''
Instantiate a Project class (with load_data set to true), instantiate a
Building class, with the project as a parent. This automatically adds the
specific building and all its future changes to the project.
'''
prj = Project(load_data = True)
bldg = Building(parent = prj)
'''Set some building parameters'''
bldg.name = "SuperExampleBuilding"
bldg.street_name = "Awesome Avenue 42"
bldg.city = "46325 Fantastic Town"
bldg.year_of_construction = 1988
bldg.number_of_floors = 1
bldg.height_of_floors = 3.5
'''Instantiate a ThermalZone class, with building as parent and set some
parameters of the thermal zone'''
tz = ThermalZone(parent = bldg)
tz.name = "Living Room"
tz.area = 140.0
tz.volume = tz.area * bldg.number_of_floors * bldg.height_of_floors
tz.infiltration_rate = 0.5
'''Instantiate UseConditions18599 class with thermal zone as parent,
and load the use conditions for the usage 'Living' '''
tz.use_conditions = BoundaryConditions(parent = tz)
tz.use_conditions.load_use_conditions("Living")
'''We save information of the Outer and Inner walls as well as Windows
in dicts, the key is the name, while the value is a list (if applicable)
[year of construciton,
construction type,
area,
tilt,
orientation]'''
out_wall_dict = {"Outer Wall 1": [bldg.year_of_construction, 'heavy',
10.0, 90.0, 0.0],
"Outer Wall 2": [bldg.year_of_construction, 'heavy',
14.0, 90.0, 90.0],
"Outer Wall 3": [bldg.year_of_construction, 'heavy',
10.0, 90.0, 180.0],
"Outer Wall 4": [bldg.year_of_construction, 'heavy',
14.0, 90.0, 270.0]}
in_wall_dict = {"Inner Wall 1": [bldg.year_of_construction, 'light', 10.0],
"Inner Wall 2": [bldg.year_of_construction, 'heavy', 14.0],
"Inner Wall 3": [bldg.year_of_construction, 'light', 10.0]}
win_dict = {"Window 1": [bldg.year_of_construction,
5.0, 90.0, 90.0],
"Window 2": [bldg.year_of_construction,
8.0, 90.0, 180.0],
"Window 3": [bldg.year_of_construction,
5.0, 90.0, 270.0]}
for key, value in out_wall_dict.items():
'''instantiate OuterWall class'''
out_wall = OuterWall(parent = tz)
out_wall.name = key
'''load typical construction, based on year of construction and
construction type'''
out_wall.load_type_element(year = value[0],
construction = value[1])
out_wall.area = value[2]
out_wall.tilt = value[3]
out_wall.orientation = value[4]
for key, value in in_wall_dict.items():
'''instantiate InnerWall class'''
in_wall = InnerWall(parent = tz)
in_wall.name = key
'''load typical construction, based on year of construction and
construction type'''
in_wall.load_type_element(year = value[0],
construction = value[1])
in_wall.area = value[2]
for key, value in win_dict.items():
'''instantiate Window class'''
win = Window(parent = tz)
win.name = key
win.area = value[1]
win.tilt = value[2]
win.orientation = value[3]
'''
We know the exact properties of the window, thus we set them instead
of loading a typical construction
'''
win.inner_convection = 1.7
win.inner_radiation = 5.0
win.outer_convection = 20.0
win.outer_radiation = 5.0
win.g_value = 0.789
win.a_conv = 0.03
win.shading_g_total = 1.0
win.shading_max_irr = 180.0
'''Instantiate a Layer class, with window as parent, set attributes'''
win_layer = Layer(parent = win)
win_layer.id = 1
win_layer.thickness = 0.024
'''Instantiate a Material class, with window layer as parent,
set attributes'''
win_material = Material(win_layer)
win_material.name = "GlasWindow"
win_material.thermal_conduc = 0.067
win_material.transmittance = 0.9
'''Define a Rooftop and a Groundfloor, we don't need to set tilt and
orientation because we take the default values'''
roof = Rooftop(parent = tz)
roof.name = "Roof"
roof.load_type_element(bldg.year_of_construction, 'heavy')
roof.area = 140.0
ground = GroundFloor(parent = tz)
ground.name = "Ground floor"
ground.load_type_element(bldg.year_of_construction, 'heavy')
ground.area = 140.0
'''
We calculate the RC Values according to AixLib procedure
'''
prj.used_library_calc = 'AixLib'
prj.number_of_elements_calc = 2
prj.merge_windows_calc = False
prj.calc_all_buildings()
'''
Export the Modelica Record
'''
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
'''Or we use Annex60 method with for elements'''
#prj.calc_all_buildings(number_of_elements=4,
# merge_windows=False,
# used_library='Annex60')
#prj.export_annex()
'''
Save new TEASER XML
'''
prj.save_gml("ExampleProject")
prj.save_citygml("Easypeasy")
def generate_archetype(self):
"""Generates a residential building.
With given values, this class generates a type residential
building according to TEASER requirements.
"""
# help area for the correct building area setting while using typeBldgs
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
self._est_ground_floor_area = type_bldg_area / self.number_of_floors
self._est_roof_area = type_bldg_area / self.number_of_floors
self._est_win_area = self.est_factor_win_area * type_bldg_area * \
(1 - self._est_factor_neighbour / 4)
self._est_outer_wall_area = (self.est_factor_facade_to_volume *
type_bldg_area *
self.height_of_floors -
self._est_ground_floor_area -
self._est_roof_area -
self._est_win_area)*(1 - self._est_factor_neighbour / 4)
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.name = key
zone.area = type_bldg_area * value[0]
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1])
zone.use_conditions = use_cond
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180.0:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(self.year_of_construction,
self.construction_type)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
'''
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime
'''
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(self.year_of_construction,
"Kunststofffenster, Isolierverglasung"
)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(self.year_of_construction,
self.construction_type)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_ground_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(self.year_of_construction,
self.construction_type)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(self.year_of_construction,
self.construction_type)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
# zone.inner_walls.append(inner_wall)
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(self.year_of_construction,
self.construction_type)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(self.year_of_construction,
self.construction_type)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
# zone.inner_walls.append(floor)
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def generate_archetype(self):
"""Generates a residential building.
With given values, this class generates a type residential
building according to TEASER requirements.
"""
# help area for the correct building area setting while using typeBldgs
self.thermal_zones = None
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
self._est_ground_floor_area = type_bldg_area / self.number_of_floors
self._est_roof_area = type_bldg_area / self.number_of_floors
self._est_win_area = self.est_factor_win_area * type_bldg_area * \
(1 - self._est_factor_neighbour / 4)
self._est_outer_wall_area = (self.est_factor_facade_to_volume *
type_bldg_area *
self.height_of_floors -
self._est_ground_floor_area -
self._est_roof_area -
self._est_win_area) *\
(1 - self._est_factor_neighbour / 4)
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.name = key
zone.area = type_bldg_area * value[0]
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1])
zone.use_conditions = use_cond
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180.0:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(self.year_of_construction,
self.construction_type)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
'''
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime
'''
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(
self.year_of_construction,
"Kunststofffenster, Isolierverglasung")
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(self.year_of_construction,
self.construction_type)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_ground_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(self.year_of_construction,
self.construction_type)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(self.year_of_construction,
self.construction_type)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
# zone.inner_walls.append(inner_wall)
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(self.year_of_construction,
self.construction_type)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(self.year_of_construction,
self.construction_type)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
# zone.inner_walls.append(floor)
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def generate_archetype(self):
'''Generates a residential building.
With given values, this class generates a type residential
building according to TEASER requirements
Berechnungsgrundlagen: IWU, "Kurzverfahren Energieprofil"; 2005.
'''
#help area for the correct building area setting while using typeBldgs
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
self._number_of_heated_floors = self._est_factor_heated_cellar + \
self.number_of_floors + self.est_living_area_factor\
*self._est_factor_heated_attic
self._living_area_per_floor = type_bldg_area / \
self._number_of_heated_floors
self._est_ground_floor_area = self.est_bottom_building_closure * \
self._living_area_per_floor
self._est_roof_area = self.est_upper_building_closure * \
self._est_factor_dormer * self._est_area_per_floor * \
self._living_area_per_floor
self._top_floor_area = self._est_area_per_roof * \
self._living_area_per_floor
if self._est_roof_area == 0:
self._est_roof_area = self._top_floor_area
self._est_facade_area = self._est_facade_to_floor_area * \
self._living_area_per_floor + self._est_extra_floor_area
self._est_win_area = self.est_factor_win_area * type_bldg_area
self._est_cellar_wall_area = self.est_factor_cellar_area * \
self._est_factor_heated_cellar * self._est_facade_area
self._est_outer_wall_area = (self._number_of_heated_floors * \
self._est_facade_area) - self._est_cellar_wall_area - \
self._est_win_area
# self._est_factor_volume = type_bldg_area * 2.5
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.name = key
zone.area = type_bldg_area * value[0]
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1])
zone.use_conditions = use_cond
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180.0:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area / \
self.nr_of_orientation
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(self.year_of_construction,
self.construction_type)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area / \
self.nr_of_orientation
'''
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime
'''
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(self.year_of_construction,
"Kunststofffenster, Isolierverglasung")
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(self.year_of_construction, \
self.construction_type)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_ground_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(self.year_of_construction, \
self.construction_type)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(self.year_of_construction,
self.construction_type)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
# zone.inner_walls.append(inner_wall)
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(self.year_of_construction,
self.construction_type)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(self.year_of_construction,
self.construction_type)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
# zone.inner_walls.append(floor)
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
def generate_archetype(self):
'''Generates an office building.
With given values, this class generates a type building according to
TEASER requirements.
'''
#help area for the correct building area setting while using typeBldgs
type_bldg_area = self.net_leased_area
self.net_leased_area = 0.0
# create zones with their corresponding area, name and usage
for key, value in self.zone_area_factors.items():
zone = ThermalZone(self)
zone.area = type_bldg_area * value[0]
zone.name = key
use_cond = UseCond(zone)
use_cond.load_use_conditions(value[1],
data_class=self.parent.data)
zone.use_conditions = use_cond
zone.use_conditions.persons = zone.area * 0.01 * \
zone.use_conditions.persons
zone.use_conditions.machines = zone.area * 0.01 * \
zone.use_conditions.machines
# self.thermal_zones.append(zone)
# statistical estimation of the facade
self._est_outer_wall_area = self.est_factor_wall_area * \
type_bldg_area ** self.est_exponent_wall
self._est_win_area = self.est_factor_win_area * \
type_bldg_area ** self.est_exponent_win
self._est_roof_area = (type_bldg_area / self.number_of_floors) * \
self.gross_factor
self._est_floor_area = (type_bldg_area / self.number_of_floors) * \
self.gross_factor
# manipulation of wall according to facade design
# (received from window_layout)
self._est_facade_area = self._est_outer_wall_area + self._est_win_area
if not self.window_layout == 0:
self._est_outer_wall_area = self._est_facade_area * \
self.corr_factor_wall
self._est_win_area = self._est_facade_area * self.corr_factor_win
else:
pass
# set the facade area to the four orientations
for key, value in self.outer_wall_names.items():
# North and South
if value[1] == 0 or value[1] == 180:
self.outer_area[value[1]] = self._est_outer_wall_area * \
(self._est_length / (2 * self._est_width + 2 * self._est_length))
# East and West
elif value[1] == 90 or value[1] == 270:
self.outer_area[value[1]] = self._est_outer_wall_area * \
(self._est_width / (2 * self._est_width + 2 * self._est_length))
for zone in self.thermal_zones:
# create wall and set building elements
outer_wall = OuterWall(zone)
outer_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
outer_wall.name = key
outer_wall.tilt = value[0]
outer_wall.orientation = value[1]
for key, value in self.window_names.items():
if value[1] == 0 or value[1] == 180:
self.window_area[value[1]] = self._est_win_area * \
(self._est_length / (2 * self._est_width + 2 * self._est_length))
elif value[1] == 90 or value[1] == 270:
self.window_area[value[1]] = self._est_win_area * \
(self._est_width / (2 * self._est_width + 2 * self._est_length))
'''
There is no real classification for windows, so this is a bit hard
code - will be fixed sometime.
'''
for zone in self.thermal_zones:
window = Window(zone)
window.load_type_element(self.year_of_construction,
"Kunststofffenster, Isolierverglasung",
data_class=self.parent.data)
window.name = key
window.tilt = value[0]
window.orientation = value[1]
for key, value in self.roof_names.items():
self.outer_area[value[1]] = self._est_roof_area
for zone in self.thermal_zones:
roof = Rooftop(zone)
roof.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
roof.name = key
roof.tilt = value[0]
roof.orientation = value[1]
# zone.outer_walls.append(roof)
for key, value in self.ground_floor_names.items():
self.outer_area[value[1]] = self._est_floor_area
for zone in self.thermal_zones:
ground_floor = GroundFloor(zone)
ground_floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
ground_floor.name = key
ground_floor.tilt = value[0]
ground_floor.orientation = value[1]
# zone.outer_walls.append(ground_floor)
for key, value in self.inner_wall_names.items():
for zone in self.thermal_zones:
inner_wall = InnerWall(zone)
inner_wall.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
inner_wall.name = key
inner_wall.tilt = value[0]
inner_wall.orientation = value[1]
# zone.inner_walls.append(inner_wall)
if self.number_of_floors > 1:
for key, value in self.ceiling_names.items():
for zone in self.thermal_zones:
ceiling = Ceiling(zone)
ceiling.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
ceiling.name = key
ceiling.tilt = value[0]
ceiling.orientation = value[1]
# zone.inner_walls.append(ceiling)
for key, value in self.floor_names.items():
for zone in self.thermal_zones:
floor = Floor(zone)
floor.load_type_element(
year=self.year_of_construction,
construction=self.construction_type,
data_class=self.parent.data)
floor.name = key
floor.tilt = value[0]
floor.orientation = value[1]
# zone.inner_walls.append(floor)
else:
pass
for key, value in self.outer_area.items():
self.set_outer_wall_area(value, key)
for key, value in self.window_area.items():
self.set_window_area(value, key)
for zone in self.thermal_zones:
zone.set_inner_wall_area()
zone.set_volume_zone()
