Coverage for bim2sim/plugins/PluginTEASER/bim2sim_teaser/models/__init__.py: 0%

1"""Package for Python representations of TEASER models""" 

2from teaser.logic.buildingobjects.building import Building as Building_Teaser 

3from teaser.logic.buildingobjects.buildingphysics.door \ 

4 import Door as Door_Teaser 

5from teaser.logic.buildingobjects.buildingphysics.floor \ 

6 import Floor as Floor_Teaser 

7from teaser.logic.buildingobjects.buildingphysics.ceiling \ 

8 import Ceiling as Ceiling_Teaser 

9from teaser.logic.buildingobjects.buildingphysics.groundfloor \ 

10 import GroundFloor as GroundFloor_Teaser 

11from teaser.logic.buildingobjects.buildingphysics.innerwall \ 

12 import InnerWall as InnerWall_Teaser 

13from teaser.logic.buildingobjects.buildingphysics.layer \ 

14 import Layer as Layer_Teaser 

15from teaser.logic.buildingobjects.buildingphysics.material \ 

16 import Material as Material_Teaser 

17from teaser.logic.buildingobjects.buildingphysics.outerwall \ 

18 import OuterWall as OuterWall_Teaser 

19from teaser.logic.buildingobjects.buildingphysics.rooftop \ 

20 import Rooftop as Rooftop_Teaser 

21from teaser.logic.buildingobjects.buildingphysics.window \ 

22 import Window as Window_Teaser 

23from teaser.logic.buildingobjects.thermalzone import \ 

24 ThermalZone as ThermalZone_Teaser 

25from teaser.logic.buildingobjects.useconditions import \ 

26 UseConditions as UseConditions_Teaser 

27from teaser.logic.buildingobjects.buildingsystems.buildingahu import \ 

28 BuildingAHU as BuildingAHU_Teaser 

29 

30from bim2sim.elements.aggregation.bps_aggregations import AggregatedThermalZone 

31from bim2sim.elements import bps_elements as bps 

32from bim2sim.elements.aggregation import bps_aggregations as bps_aggr 

33from bim2sim.elements.mapping.units import ureg 

34from bim2sim.plugins.PluginTEASER.bim2sim_teaser import export 

35 

36 

37class TEASER(export.TEASERExportInstance): 

38 library = "TEASER" 

39 

40 

41class Building(TEASER, Building_Teaser): 

42 represents = [bps.Building] 

43 

44 def __init__(self, bim2sim_element, parent): 

45 Building_Teaser.__init__(self, parent=parent) 

46 TEASER.__init__(self, bim2sim_element) 

47 self.used_library_calc = "AixLib" 

48 self.add_thermal_zones_to_building() 

49 if bim2sim_element.with_ahu: 

50 self.central_ahu = BuildingAHU( 

51 element=bim2sim_element, parent=self) 

52 

53 def add_thermal_zones_to_building(self): 

54 for tz in self.element.thermal_zones: 

55 ThermalZone(tz, parent=self) 

56 

57 def request_params(self): 

58 self.request_param("bldg_name", None, "name") 

59 self.request_param("year_of_construction", 

60 self.check_numeric( 

61 min_value=0 * ureg.year), export_unit=ureg.year) 

62 self.request_param("number_of_storeys", 

63 self.check_numeric( 

64 min_value=1 * ureg.dimensionless), 

65 "number_of_floors") 

66 self.request_param("avg_storey_height", 

67 self.check_numeric( 

68 min_value=1 * ureg.meter), 

69 "height_of_floors") 

70 # todo workaround until setter method is changed in TEASER, see TEASER 

71 # issue #772 

72 self.request_param("with_ahu", export_name="_with_ahu") 

73 

74 

75class ThermalZone(TEASER, ThermalZone_Teaser): 

76 represents = [bps.ThermalZone, AggregatedThermalZone] 

77 

78 def __init__(self, element, parent): 

79 ThermalZone_Teaser.__init__(self, parent=parent) 

80 TEASER.__init__(self, element) 

81 self.number_of_elements = 2 

82 self.use_conditions = UseConditions(element=element, parent=self) 

83 self.add_elements_to_thermal_zone() 

84 

85 def add_elements_to_thermal_zone(self): 

86 for bound_element in self.element.bound_elements: 

87 export.TEASERExportInstance.factory(bound_element, parent=self) 

88 

89 def request_params(self): 

90 if self.element.guid: 

91 self.name = self.element.guid 

92 else: 

93 self.request_param("name", None) 

94 self.request_param("net_area", 

95 self.check_numeric( 

96 min_value=0 * ureg.meter ** 2), 

97 "area") 

98 self.request_param("t_ground", None) 

99 self.request_param("net_volume", 

100 None, 

101 "volume") 

102 

103 

104class BuildingAHU(TEASER, BuildingAHU_Teaser): 

105 represents = [] 

106 

107 def __init__(self, element, parent): 

108 BuildingAHU_Teaser.__init__(self, parent=parent) 

109 self.overwrite_teaser_defaults() 

110 TEASER.__init__(self, element) 

111 

112 def overwrite_teaser_defaults(self): 

113 """Overwrites default BuildingAHU values from TEASER 

114 

115 This is required as TEASER sets defaults for e.g. the AHU setup and in 

116 enrichment we only enrich not-existing values. Without setting the 

117 defaults back to None would lead to errors. 

118 """ 

119 self.heating = None 

120 self.cooling = None 

121 self.dehumidification = None 

122 self.humidification = None 

123 self.heat_recovery = None 

124 self.efficiency_recovery = None 

125 

126 def request_params(self): 

127 self.request_param("ahu_heating", export_name="heating") 

128 self.request_param("ahu_cooling", export_name="cooling") 

129 self.request_param("ahu_dehumidification", 

130 export_name="dehumidification") 

131 self.request_param("ahu_humidification", export_name="humidification") 

132 self.request_param("ahu_heat_recovery", export_name="heat_recovery") 

133 self.request_param("ahu_heat_recovery_efficiency", 

134 export_name="efficiency_recovery") 

135 

136 

137class UseConditions(TEASER, UseConditions_Teaser): 

138 represents = [] 

139 

140 def __init__(self, element, parent): 

141 UseConditions_Teaser.__init__(self, parent=parent) 

142 self.overwrite_teaser_defaults() 

143 TEASER.__init__(self, element) 

144 

145 def overwrite_teaser_defaults(self): 

146 """Overwrites default use conditions values from TEASER 

147 

148 This is required as TEASER sets defaults for e.g. the usage and in 

149 enrichment we only enrich not-existing values. Without setting the 

150 defaults back to None would lead to errors. 

151 """ 

152 self.usage = None 

153 

154 self.with_heating = True 

155 self.with_cooling = False 

156 self.T_threshold_heating = None 

157 self.T_threshold_cooling = None 

158 

159 self.fixed_heat_flow_rate_persons = None 

160 self.activity_degree_persons = None 

161 self._persons = None 

162 self.internal_gains_moisture_no_people = None 

163 self.ratio_conv_rad_persons = None 

164 

165 self.machines = None 

166 self.ratio_conv_rad_machines = None 

167 

168 self.lighting_power = None 

169 self.ratio_conv_rad_lighting = None 

170 

171 self.use_constant_infiltration = None 

172 self.base_infiltration = None 

173 self.max_user_infiltration = None 

174 self.max_overheating_infiltration = [] 

175 self.max_summer_infiltration = [] 

176 self.winter_reduction_infiltration = [] 

177 

178 self.min_ahu = None 

179 self.max_ahu = None 

180 self.with_ahu = None 

181 

182 self._first_saturday_of_year = 1 

183 self.profiles_weekend_factor = None 

184 

185 self._set_back_times = None 

186 self.heating_set_back = -2 

187 self.cooling_set_back = 2 

188 

189 self._adjusted_opening_times = None 

190 

191 self._with_ideal_thresholds = False 

192 

193 self._heating_profile = [] 

194 self._cooling_profile = [] 

195 self._persons_profile = [] 

196 self._machines_profile = [] 

197 self._lighting_profile = [] 

198 

199 self._schedules = None 

200 

201 def request_params(self): 

202 self.request_param("name", None) 

203 self.request_param("with_cooling", None) 

204 self.request_param("with_heating", None) 

205 self.request_param("with_ahu", None) 

206 self.request_param("heating_profile", None) 

207 self.request_param("cooling_profile", None) 

208 self.request_param("persons", None) 

209 self.request_param("T_threshold_heating", None) 

210 self.request_param("activity_degree_persons", None) 

211 self.request_param("fixed_heat_flow_rate_persons", None, 

212 export_unit=ureg.W) 

213 self.request_param("internal_gains_moisture_no_people", None) 

214 self.request_param("T_threshold_cooling", None) 

215 self.request_param("ratio_conv_rad_persons", None) 

216 self.request_param("machines", None, 

217 export_unit=ureg.W/ureg.m**2) 

218 self.request_param("ratio_conv_rad_machines", None) 

219 self.request_param("lighting_power", 

220 None, export_unit=ureg.W/ureg.m**2) 

221 self.request_param("ratio_conv_rad_lighting", None) 

222 self.request_param("use_constant_infiltration", None) 

223 self.request_param("base_infiltration", None) 

224 self.request_param("max_user_infiltration", None) 

225 self.request_param("max_overheating_infiltration", None) 

226 self.request_param("max_summer_infiltration", None) 

227 self.request_param("winter_reduction_infiltration", None) 

228 self.request_param("min_ahu", None) 

229 self.request_param("max_ahu", None) 

230 self.request_param("with_ideal_thresholds", None) 

231 self.request_param("persons_profile", None) 

232 self.request_param("machines_profile", None) 

233 self.request_param("lighting_profile", None) 

234 self.request_param("usage", None) 

235 

236 

237class ElementWithLayers(TEASER): 

238 

239 def __init__(self, element): 

240 self.add_layers_to_element(element) 

241 super().__init__(element) 

242 self.name = self.element.guid 

243 

244 

245 def add_layers_to_element(self, element): 

246 if element.layerset: 

247 if element.layerset.layers: 

248 for layer in element.layerset.layers: 

249 Layer(layer, parent=self) 

250 

251 def __repr__(self): 

252 return "<%s>" % type(self).__name__ 

253 

254 

255class InnerWall(ElementWithLayers, InnerWall_Teaser): 

256 represents = [ 

257 bps.InnerDoor, 

258 bps.InnerWall, 

259 bps_aggr.InnerWallDisaggregated 

260 ] 

261 

262 def __init__(self, element, parent): 

263 InnerWall_Teaser.__init__(self, parent=parent) 

264 ElementWithLayers.__init__(self, element) 

265 

266 def request_params(self): 

267 self.orientation = self.element.teaser_orientation 

268 self.request_param("net_area", 

269 self.check_numeric(min_value=0 * ureg.m ** 2), 

270 "area") 

271 self.request_param("inner_convection", 

272 self.check_numeric( 

273 min_value=0 * ureg.W / ureg.K / ureg.meter ** 

274 2), 

275 "inner_convection") 

276 

277 

278class OuterWall(ElementWithLayers, OuterWall_Teaser): 

279 represents = [bps.OuterWall, bps_aggr.OuterWallDisaggregated] 

280 

281 def __init__(self, element, parent): 

282 OuterWall_Teaser.__init__(self, parent=parent) 

283 ElementWithLayers.__init__(self, element) 

284 

285 def request_params(self): 

286 self.orientation = self.element.teaser_orientation 

287 self.request_param("net_area", 

288 self.check_numeric(min_value=0 * ureg.m ** 2), 

289 "area") 

290 self.request_param("tilt", None, "tilt") 

291 

292 

293class Rooftop(ElementWithLayers, Rooftop_Teaser): 

294 represents = [bps.Roof, bps_aggr.RoofDisaggregated] 

295 

296 def __init__(self, element, parent): 

297 Rooftop_Teaser.__init__(self, parent=parent) 

298 ElementWithLayers.__init__(self, element) 

299 

300 def request_params(self): 

301 self.request_param("net_area", 

302 self.check_numeric(min_value=0 * ureg.m ** 2), 

303 "area") 

304 

305 

306class Floor(ElementWithLayers, Floor_Teaser): 

307 represents = [bps.InnerFloor, bps_aggr.InnerFloorDisaggregated] 

308 

309 def __init__(self, element, parent): 

310 Floor_Teaser.__init__(self, parent=parent) 

311 ElementWithLayers.__init__(self, element) 

312 

313 def request_params(self): 

314 self.request_param("net_area", 

315 self.check_numeric(min_value=0 * ureg.m ** 2), 

316 "area") 

317 

318 

319class Ceiling(ElementWithLayers, Ceiling_Teaser): 

320 represents = [bps.InnerFloor, bps_aggr.InnerFloorDisaggregated] 

321 

322 def __init__(self, element, parent): 

323 Ceiling_Teaser.__init__(self, parent=parent) 

324 ElementWithLayers.__init__(self, element) 

325 

326 def request_params(self): 

327 self.request_param("net_area", 

328 self.check_numeric(min_value=0 * ureg.m ** 2), 

329 "area") 

330 

331 

332class GroundFloor(ElementWithLayers, GroundFloor_Teaser): 

333 represents = [bps.GroundFloor, bps_aggr.GroundFloorDisaggregated] 

334 

335 def __init__(self, element, parent): 

336 GroundFloor_Teaser.__init__(self, parent=parent) 

337 ElementWithLayers.__init__(self, element) 

338 

339 def request_params(self): 

340 self.request_param("net_area", 

341 self.check_numeric(min_value=0 * ureg.m ** 2), 

342 "area") 

343 

344 

345class Window(ElementWithLayers, Window_Teaser): 

346 represents = [bps.Window, bps_aggr.WindowDisaggregated] 

347 

348 def __init__(self, element, parent): 

349 Window_Teaser.__init__(self, parent=parent) 

350 ElementWithLayers.__init__(self, element) 

351 

352 def request_params(self): 

353 self.orientation = self.element.teaser_orientation 

354 self.request_param("gross_area", 

355 self.check_numeric(min_value=0 * ureg.m ** 2), 

356 "area") 

357 self.request_param("a_conv", None) 

358 self.request_param("g_value", None) 

359 self.request_param("inner_convection", None) 

360 self.request_param("inner_radiation", None) 

361 self.request_param("outer_radiation", None) 

362 self.request_param("outer_convection", None) 

363 self.request_param("shading_g_total", None) 

364 self.request_param("shading_max_irr", None) 

365 

366 

367class Door(ElementWithLayers, Door_Teaser): 

368 represents = [ 

369 bps.OuterDoor, 

370 bps.Door, 

371 bps_aggr.OuterDoorDisaggregated 

372 ] 

373 

374 def __init__(self, element, parent): 

375 Door_Teaser.__init__(self, parent=parent) 

376 ElementWithLayers.__init__(self, element) 

377 

378 def request_params(self): 

379 self.orientation = self.element.teaser_orientation 

380 self.request_param("gross_area", 

381 self.check_numeric(min_value=0 * ureg.m ** 2), 

382 "area") 

383 self.request_param("inner_convection", None) 

384 

385 

386class Layer(TEASER, Layer_Teaser): 

387 represents = [bps.Layer] 

388 

389 def __init__(self, element: bps.Layer, parent): 

390 Layer_Teaser.__init__(self, parent=parent) 

391 TEASER.__init__(self, element) 

392 Material(element.material, parent=self) 

393 

394 def request_params(self): 

395 self.request_param("thickness", None) 

396 

397 def __repr__(self): 

398 return "<%s>" % type(self).__name__ 

399 

400 

401class Material(TEASER, Material_Teaser): 

402 # represents = [element.Material] 

403 

404 def __init__(self, element, parent): 

405 Material_Teaser.__init__(self, parent=parent) 

406 TEASER.__init__(self, element) 

407 

408 def request_params(self): 

409 self.name = self.element.material 

410 self.request_param("density", None) 

411 self.request_param( 

412 "spec_heat_capacity", None, "heat_capac", 

413 export_unit=ureg.kilojoule / (ureg.kg * ureg.K)) 

414 self.request_param("thermal_conduc", None)