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 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 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 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 generate_from_gml(self): """Enriches lod1 or lod2 data from CityGML Adds Zones, BoundaryConditions, Material settings for walls and windows to the geometric representation of CityGML """ 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.with_ahu = False zone.use_conditions.persons *= zone.area * 0.01 zone.use_conditions.machines *= zone.area * 0.01 for surface in self.gml_surfaces: if surface.surface_tilt is not None: if surface.surface_tilt == 90: 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 = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation window = Window(zone) window.load_type_element(self.year_of_construction, "Kunststofffenster, " "Isolierverglasung", data_class=self.parent.data) window.name = "asd" + str(surface.surface_tilt) window.tilt = surface.surface_tilt window.orientation = surface.surface_orientation elif surface.surface_tilt == 0 and \ surface.surface_orientation == \ -2: outer_wall = GroundFloor(zone) outer_wall.load_type_element( year=self.year_of_construction, construction=self.construction_type, data_class=self.parent.data) outer_wall.name = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation else: outer_wall = Rooftop(zone) outer_wall.load_type_element( year=self.year_of_construction, construction=self.construction_type, data_class=self.parent.data) outer_wall.name = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation 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] 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 surface in self.gml_surfaces: if surface.surface_tilt is not None: if surface.surface_tilt != 0 and surface.surface_orientation\ != -2 and surface.surface_orientation != -1: self.set_outer_wall_area( surface.surface_area * (1 - self.est_factor_win_area), surface.surface_orientation) else: self.set_outer_wall_area(surface.surface_area, surface.surface_orientation) for surface in self.gml_surfaces: if surface.surface_tilt != 0 and surface.surface_orientation != \ -2 and surface.surface_orientation != -1: self.set_window_area( surface.surface_area * self.est_factor_win_area, surface.surface_orientation) 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 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_from_gml(self): """enriches lod1 or lod2 data from citygml adds Zones, BoundaryConditions, Material settings for walls and windows to the geometric representation of CityGML number or height of floors need to be specified """ 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]) 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 surface in self.gml_surfaces: if surface.surface_tilt == 90: outer_wall = OuterWall(zone) outer_wall.load_type_element(self.year_of_construction, self.construction_type) outer_wall.name = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation window = Window(zone) window.load_type_element(self.year_of_construction, "Kunststofffenster, Isolierverglasung") window.name = "asd"+str(surface.surface_tilt) window.tilt = surface.surface_tilt window.orientation = surface.surface_orientation elif surface.surface_tilt == 0 and surface.surface_orientation ==\ -2: outer_wall = GroundFloor(zone) outer_wall.load_type_element(self.year_of_construction, self.construction_type) outer_wall.name = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation else: outer_wall = Rooftop(zone) outer_wall.load_type_element(self.year_of_construction, self.construction_type) outer_wall.name = surface.name outer_wall.tilt = surface.surface_tilt outer_wall.orientation = surface.surface_orientation 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] 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] 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] else: pass for surface in self.gml_surfaces: self.set_outer_wall_area(surface.surface_area * (1- self.est_factor_win_area), surface.surface_orientation) for surface in self.gml_surfaces: if surface.surface_tilt != 0 and surface.surface_orientation !=\ -2 and surface.surface_orientation != -1: self.set_window_area(surface.surface_area * self.est_factor_win_area, surface.surface_orientation) 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()