Coverage for bim2sim/plugins/PluginComfort/bim2sim_comfort/task/plot_comfort_results.py: 0%

1import json 

2import logging 

3from pathlib import Path 

4from textwrap import wrap 

5from typing import List 

6 

7import matplotlib as mpl 

8import numpy as np 

9import pandas as pd 

10from RWTHColors import ColorManager 

11from matplotlib import pyplot as plt 

12from matplotlib.colors import ListedColormap, Normalize, BoundaryNorm 

13import seaborn as sns 

14 

15from bim2sim.elements.mapping.units import ureg 

16from bim2sim.tasks.bps import PlotBEPSResults 

17from bim2sim.utilities.common_functions import filter_elements 

18from bim2sim.utilities.types import BoundaryOrientation 

19 

20INCH = 2.54 

21 

22logger = logging.getLogger(__name__) 

23cm = ColorManager() 

24plt.rcParams.update(mpl.rcParamsDefault) 

25plt.style.use(['science', 'grid', 'rwth']) 

26plt.style.use(['science', 'no-latex']) 

27 

28# Update rcParams for font settings 

29plt.rcParams.update({ 

30 'font.size': 20, 

31 'font.family': 'sans-serif', # Use sans-serif font 

32 'font.sans-serif': ['Arial', 'Helvetica', 'DejaVu Sans', 'sans-serif'], 

33 # Specify sans-serif fonts 

34 'legend.frameon': True, 

35 'legend.facecolor': 'white', 

36 'legend.framealpha': 0.5, 

37 'legend.edgecolor': 'black', 

38 "lines.linewidth": 0.4, 

39 "text.usetex": False, # use inline math for ticks 

40 "pgf.rcfonts": True, 

41}) 

42 

43 

44class PlotComfortResults(PlotBEPSResults): 

45 reads = ('df_finals', 'sim_results_path', 'ifc_files', 'elements') 

46 final = True 

47 

48 def run(self, df_finals: dict, sim_results_path: Path, 

49 ifc_files: List[Path], elements: dict): 

50 """Plots the results for BEPS simulations. 

51 

52 This holds pre configured functions to plot the results of the BEPS 

53 simulations with the EnergyPlus-based PluginComfort . 

54 

55 Args: 

56 df_finals: dict of final results where key is the building name and 

57 value is the dataframe holding the results for this building 

58 sim_results_path: base path where to store the plots 

59 ifc_files: bim2sim IfcFileClass holding the ifcopenshell ifc instance 

60 elements (dict): Dictionary of building elements. 

61 """ 

62 if not self.playground.sim_settings.create_plots: 

63 logger.info("Visualization of Comfort Results is skipped ...") 

64 return 

65 logger.info("Visualization of Comfort Results started ...") 

66 plot_single_guid = self.playground.sim_settings.plot_singe_zone_guid 

67 new_zone_names = None 

68 zone_dict_path = sim_results_path / self.prj_name / 'zone_dict.json' 

69 with open(zone_dict_path) as j: 

70 zone_dict = json.load(j) 

71 if plot_single_guid: 

72 logger.info("Check if plot_single_guid is valid space name.") 

73 if not plot_single_guid in zone_dict.keys(): 

74 plot_single_guid = '' 

75 logger.info("Requested plot_single_guid is not found in IFC " 

76 "file, plotting results for all spaces instead.") 

77 if self.playground.sim_settings.rename_plot_keys: 

78 # load keys to rename space names for plotting 

79 with open(self.playground.sim_settings.rename_plot_keys_path) as rk: 

80 rename_keys = json.load(rk) 

81 zone_dict_ext_path = sim_results_path / self.prj_name / 'zone_dict_ifc_names.json' 

82 with open(zone_dict_ext_path) as j: 

83 zone_dict_ifc_names = json.load(j) 

84 zone_dict, new_zone_names = self.rename_zone_usage(zone_dict, 

85 zone_dict_ifc_names, 

86 rename_keys, sim_results_path) 

87 if new_zone_names: 

88 zone_dict = new_zone_names 

89 for bldg_name, df in df_finals.items(): 

90 export_path = sim_results_path / bldg_name / 'plots' 

91 if not export_path.exists(): 

92 export_path.mkdir(parents=False, exist_ok=False) 

93 spaces = filter_elements(elements, 'ThermalZone') 

94 if self.playground.sim_settings.plot_zone_usages: 

95 # only plot results for a selection of zone usages. This 

96 # reduces the computational overhead, e.g., if only single 

97 # offices are plotted 

98 exclude_guids = [] 

99 for space in spaces: 

100 if not any(key.lower() in space.usage.lower() for key in 

101 self.playground.sim_settings.plot_zone_usages)\ 

102 and not space.guid.lower() == plot_single_guid: 

103 exclude_guids.append(space.guid) 

104 logger.info(f'Exclude space {space.usage} ' 

105 f'{space.guid} and its space boundaries ' 

106 f'from further evaluation due to ' 

107 f'sim_setting.') 

108 for bound in space.space_boundaries: 

109 exclude_guids.append(bound.guid) 

110 filtered_columns = [ 

111 col for col in df.columns 

112 if not any( 

113 exclude_guid.lower() in col.lower() for exclude_guid in 

114 exclude_guids) 

115 ] 

116 filtered_df = df[filtered_columns] 

117 df = filtered_df 

118 # add a limited local comfort analysis based on the surface 

119 # temperatures calculated in EnergyPlus and the limits defined in 

120 # DIN EN 16798-1 National Appendix. This evaluates 

121 # minimum/maximum surface temperatures and differences to the air 

122 # temperature. 

123 self.limited_local_comfort_DIN16798_NA(df, elements, export_path) 

124 

125 # generate DIN EN 16798-1 adaptive comfort scatter plot and 

126 # return analysis of comfort categories for further plots 

127 if not plot_single_guid: 

128 # generate plots and data for scatter plots for all spaces 

129 cat_analysis, cat_analysis_occ, cat_analysis_occ_hours = ( 

130 self.apply_en16798_to_all_zones(df, zone_dict, 

131 export_path)) 

132 else: 

133 # only generate plots and data for a selected single space GUID 

134 cat_analysis, cat_analysis_occ, cat_analysis_occ_hours = ( 

135 self.apply_en16798_to_single_zone(df, zone_dict, 

136 export_path, 

137 plot_single_guid)) 

138 # plot a barplot combined with table of comfort categories from 

139 # DIN EN 16798. 

140 # general table bar plot considering all generated data 

141 self.table_bar_plot_16798(cat_analysis, export_path) 

142 # table bar plot, only evaluating the occupied time (in %) 

143 self.table_bar_plot_16798(cat_analysis_occ, export_path, tag='occ') 

144 # table bar plot, evaluating the exceeding temperature degree 

145 # hours for the occupied time of the year. 

146 self.table_bar_plot_16798(cat_analysis_occ_hours, export_path, 

147 tag='occ_hours', normalize=False, 

148 unit=f"{ureg.kelvin*ureg.hour:~P}", 

149 unit_name='Degree hours', 

150 y_scale='linear') 

151 

152 # generate plots for Fanger's PMV 

153 fanger_pmv = df[[col for col in df.columns if 'fanger_pmv' in col]] 

154 if plot_single_guid: 

155 fanger_pmv = fanger_pmv[[col for col in fanger_pmv.columns if 

156 plot_single_guid in col]] 

157 self.pmv_plot(fanger_pmv, export_path, 

158 f"pmv_{plot_single_guid}") 

159 

160 for space in spaces: 

161 if not any(fanger_pmv.filter(like=space.guid)): 

162 continue 

163 self.logger.info(f"Space: {space.usage}, GUID: {space.guid}") 

164 col = fanger_pmv.filter(like=space.guid).columns[0] 

165 # visualize heatmap of PMV 

166 self.visualize_heatmap(fanger_pmv, col, export_path, 

167 save_as='heatmap_', 

168 zone_dict=zone_dict, 

169 color_categories='PMV', guid=space.guid) 

170 # generate calendar plot for daily mean pmv results 

171 # self.visualize_calendar(pd.DataFrame(fanger_pmv[col]), 

172 # export_path, save_as='calendar_', 

173 # add_title=True, 

174 # color_only=True, figsize=[11, 12], 

175 # zone_dict=zone_dict, guid=space.guid) 

176 

177 @staticmethod 

178 def visualize_heatmap(df, col, export_path, save_as='', 

179 add_title=False, save=True, zone_dict='', year='', 

180 color_categories='', guid=''): 

181 """ 

182 Visualize heatmap of Fanger PMV. 

183 Args: 

184 df: Input dataframe with PMV data 

185 col: PMV column 

186 export_path: plot export path 

187 save_as: prefix for saving files 

188 add_title: True if title should be added to plot 

189 save: True if plot should be saved instead of displayed 

190 zone_dict: dictionary to rename the space names 

191 year: string to add the value of the year 

192 color_categories: select 'PMV', 'PPD'. Standard heatmap is 

193 applied if left blank 

194 guid: plot individual space GUID 

195 

196 Returns: 

197 

198 """ 

199 def color_mapper_pmv(value): 

200 if -0.2 < value < 0.2: 

201 return 'green' # CAT I 

202 elif -0.5 < value <= -0.2: 

203 return 'lightblue' # CAT II low 

204 elif 0.2 <= value < 0.5: 

205 return 'yellow' # CAT II high 

206 elif -0.7 < value <= -0.5: 

207 return 'mediumblue' # CAT III low 

208 elif 0.5 <= value < 0.7: 

209 return 'orange' # CAT III high 

210 elif value <= -0.7: 

211 return 'darkblue' # CAT IV low 

212 elif value >= 0.7: 

213 return 'red' # CAT IV high 

214 else: 

215 return 'black' 

216 

217 def color_mapper_ppd(value): 

218 if value < 6: 

219 return 'green' # CAT I 

220 elif 6 <= value < 10: 

221 return 'yellow' # CAT II 

222 elif 10 <= value < 15: 

223 return 'orange' # CAT III 

224 elif 15 <= value < 25: 

225 return 'red' # CAT IV 

226 elif value >= 25: 

227 return 'purple' # out of range 

228 else: 

229 return 'black' 

230 

231 series = pd.Series(df[col], index=df.index) 

232 # Create a MultiIndex for day and hour 

233 series.index = pd.MultiIndex.from_arrays( 

234 [series.index.date, series.index.hour], 

235 names=['Month', 'Hour'] 

236 ) 

237 

238 # Aggregate the data (for example, taking the mean) 

239 heatmap_data = series.unstack(level='Hour') 

240 plt.figure(figsize=(14 / INCH, 8 / INCH)) 

241 

242 # plt.title('Heatmap of Hourly Data') 

243 if color_categories: 

244 ncol = None 

245 if color_categories == 'PMV': 

246 color_data = heatmap_data.apply( 

247 lambda col: col.map(color_mapper_pmv)) 

248 color_counts_absolute = color_data.stack().value_counts() 

249 color_counts_relative = ( 

250 round((color_counts_absolute / color_counts_absolute.sum( 

251 )) * 100, 1)) 

252 unique_colors = ['green', 

253 'white', # dummy color for legend 

254 'lightblue', 'yellow', 

255 'mediumblue', 

256 'orange', 'darkblue', 'red', 'black'] 

257 for color in unique_colors: 

258 if color not in color_counts_relative.index: 

259 color_counts_relative[color] = 0 

260 labels = { 

261 f'CAT I ({color_counts_relative["green"]}%)': 'green', 

262 '': 'white', # add dummy color for legend arrangement 

263 f'CAT II low ({color_counts_relative["lightblue"]}%)': 

264 'lightblue', 

265 f'CAT II high ({color_counts_relative["yellow"]}%)': 'yellow', 

266 f'CAT III low ({color_counts_relative["mediumblue"]}%)': 'mediumblue', 

267 f'CAT III high ({color_counts_relative["orange"]}%)': 'orange', 

268 f'CAT IV low ({color_counts_relative["darkblue"]}%)': 'darkblue', 

269 f'CAT IV high ({color_counts_relative["red"]}%)': 'red' 

270 } 

271 ncol = 4 

272 if color_categories == 'PPD': 

273 color_data = heatmap_data.apply( 

274 lambda col: col.map(color_mapper_ppd)) 

275 color_counts_absolute = color_data.stack().value_counts() 

276 color_counts_relative = ( 

277 round((color_counts_absolute / color_counts_absolute.sum( 

278 ) * 100), 1)) 

279 unique_colors = ['green', 

280 'white', # dummy color for legend arrangement 

281 'yellow', 'orange', 'red', 

282 'purple', 

283 'black'] 

284 for color in unique_colors: 

285 if color not in color_counts_relative.index: 

286 color_counts_relative[color] = 0 

287 labels = { 

288 f'CAT I ({color_counts_relative["green"]}%)': 'green', 

289 '': 'white', # dummy color for legend arrangement 

290 f'CAT II ({color_counts_relative["yellow"]}%)': 'yellow', 

291 f'CAT III ({color_counts_relative["orange"]}%)': 'orange', 

292 f'CAT IV ({color_counts_relative["red"]}%)': 'red', 

293 f'Out of range ({color_counts_relative["purple"]}%)': 'purple', 

294 } 

295 ncol = 3 

296 cmap = ListedColormap(unique_colors) 

297 color_to_num = {color: num for num, color in 

298 enumerate(unique_colors)} 

299 numeric_data = color_data.apply(lambda col: col.map(color_to_num)) 

300 norm = BoundaryNorm(range(len(unique_colors) + 1), cmap.N) 

301 sns.heatmap(numeric_data.T, cmap=cmap, norm=norm, cbar=False) 

302 handles = [plt.Line2D([0], [0], marker='o', color='w', label=label, 

303 markerfacecolor=color, markersize=4) for 

304 label, color in labels.items()] 

305 plt.subplots_adjust(right=0.9, bottom=0.3, top=0.9, 

306 left=0.1) # Adjust right side to 

307 plt.legend(handles=handles, bbox_to_anchor=(-0.1, -0.2), 

308 loc='upper left', frameon=False, ncol=ncol, 

309 columnspacing=0.8, 

310 handletextpad=-0.05, # borderaxespad=0.5, 

311 fontsize=8) 

312 else: 

313 sns.heatmap(heatmap_data.T, cmap='viridis', cbar=True) 

314 

315 # Customize x-ticks to show month abbreviations 

316 month_labels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 

317 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] 

318 

319 # Extract unique days from columns and convert them back to datetime 

320 # objects for labeling 

321 days = pd.to_datetime(heatmap_data.T.columns) 

322 

323 # Set x-ticks with abbreviated month names and day numbers 

324 # Filter for ticks where day.day == 1 and create corresponding labels 

325 filtered_ticks = [i for i, day in enumerate(days) if day.day == 1] 

326 filtered_labels = [f"{month_labels[day.month - 1]}" for day in 

327 days if day.day == 1] 

328 

329 # Set x-ticks with abbreviated month names only at desired positions 

330 plt.xticks(ticks=filtered_ticks, labels=filtered_labels, rotation=45, 

331 fontsize=8) 

332 plt.ylim([24.01, 0]) 

333 plt.yticks(np.arange(0, 25, step=4), np.arange(0, 25, step=4), 

334 rotation=0, 

335 fontsize=8) 

336 plt.ylabel('Hour of the day', size=8) 

337 plt.xlabel('', size=8) 

338 title_name = col 

339 for key, item in zone_dict.items(): 

340 if key in title_name: 

341 title_name = title_name.replace(key, item) #+ '_' + 

342 # guid 

343 if add_title: 

344 plt.title(str(year) + ' ' + title_name, fontsize=3) 

345 if save: 

346 plt.savefig(export_path / str( 

347 save_as.replace('/','_') 

348 + title_name.replace('/', '_') + f"_{year}_" 

349 + color_categories + '.pdf'), bbox_inches='tight') 

350 

351 def limited_local_comfort_DIN16798_NA(self, df, elements, export_path, 

352 occupied=True): 

353 """ 

354 Calculate a limited local comfort using surface temperatures from 

355 EnergyPlus and limits from DIN EN 16798-1 (National Appendix). 

356 Args: 

357 df: result dataframe 

358 elements: bim2sim elements 

359 export_path: export path for result plots and data 

360 occupied: True if only occupied states should be evaluated 

361 

362 Returns: 

363 

364 """ 

365 spaces = filter_elements(elements, 'ThermalZone') 

366 local_discomfort_dict = {} 

367 global_local_discomfort = pd.DataFrame(columns=['TimeStamp', 

368 'space', 

369 'space_temperature', 

370 'wall_min', 

371 'wall_max', 

372 'floor_min', 

373 'floor_max', 

374 'ceiling_min', 

375 'ceiling_max']) 

376 local_discomfort_overview = pd.DataFrame(columns=['space', 

377 'wall_min', 

378 'wall_max', 

379 'floor_min', 

380 'floor_max', 

381 'ceiling_min', 

382 'ceiling_max']) 

383 initial_row = {col: True for col in local_discomfort_overview.columns if 

384 col != 'space'} 

385 # only proceed if surface temperatures are available in the dataframe 

386 if not any(df.filter(like='surf_inside_temp')): 

387 self.logger.warning("No surface temperatures found. Set " 

388 "sim_setting cfd_export to True to enable " 

389 "local limited comfort analysis using " 

390 "EnergyPlus.") 

391 return 

392 for space in spaces: 

393 space_local_discomfort = pd.DataFrame( 

394 columns=global_local_discomfort.columns) 

395 bound_temperatures_found = False 

396 if not any(df.filter(like=space.guid)): 

397 continue 

398 self.logger.info(f"Space: {space.usage}, GUID: {space.guid}") 

399 local_discomfort_dict.update({ 

400 space.guid: 

401 { 

402 'wall': {'min': {'count': 0, 

403 'hours': 0}, 

404 'max': {'count': 0, 

405 'hours': 0}}, 

406 'floor': {'min': {'count': 0, 

407 'hours': 0}, 

408 'max': {'count': 0, 

409 'hours': 0}}, 

410 'ceiling': 

411 {'min': {'count': 0, 

412 'hours': 0}, 

413 'max': {'count': 0, 

414 'hours': 0}}, 

415 }}) 

416 new_row = {**initial_row, 'space': space.guid} 

417 local_discomfort_overview = pd.concat( 

418 [local_discomfort_overview, pd.DataFrame([new_row])], 

419 ignore_index=True) 

420 space_temperature = df[f"air_temp_rooms_{space.guid}"].apply( 

421 lambda x: x.magnitude) 

422 if occupied: 

423 n_persons_df = df['n_persons_rooms_' + space.guid] 

424 common_index = space_temperature.index.intersection( 

425 n_persons_df.index) 

426 space_temperature = space_temperature.loc[common_index][ 

427 n_persons_df.loc[common_index] > 0] 

428 space_local_discomfort = space_local_discomfort.reindex( 

429 index=space_temperature.index) 

430 wall_df = pd.DataFrame() 

431 floor_df = pd.DataFrame() 

432 ceiling_df = pd.DataFrame() 

433 

434 for bound in space.space_boundaries: 

435 bound_temperature = df.filter(like=bound.guid) 

436 if bound_temperature.empty or bound.bound_element is None: 

437 continue 

438 else: 

439 bound_temperatures_found = True 

440 try: 

441 bound_temperature = bound_temperature.iloc[:, 0].apply( 

442 lambda x: x.magnitude) 

443 except AttributeError: 

444 self.logger.warning(f"object has no attribute 'magnitude'") 

445 if occupied: 

446 common_index = bound_temperature.index.intersection( 

447 n_persons_df.index) 

448 bound_temperature = bound_temperature.loc[common_index][ 

449 n_persons_df.loc[common_index] > 0] 

450 if 'WALL' in bound.bound_element.element_type.upper(): 

451 wall_df = pd.concat([wall_df, bound_temperature], axis=1) 

452 if (('FLOOR' in bound.bound_element.element_type.upper() and 

453 bound.top_bottom == BoundaryOrientation.top) or 

454 ('ROOF' in bound.bound_element.element_type.upper())): 

455 ceiling_df = pd.concat([ceiling_df, bound_temperature], 

456 axis=1) 

457 if ('FLOOR' in bound.bound_element.element_type.upper() 

458 and bound.top_bottom == BoundaryOrientation.bottom): 

459 floor_df = pd.concat([floor_df, bound_temperature], axis=1) 

460 space_local_discomfort = space_local_discomfort.reindex( 

461 index=bound_temperature.index) 

462 if not bound_temperatures_found: 

463 self.logger.warning(f"No bound temperatures found in space " 

464 f"{space.usage} {space.guid}. No limited " 

465 f"local comfort analyzed.") 

466 continue 

467 min_wall_df, max_wall_df = self.get_exceeded_temperature_hours( 

468 wall_df, 

469 -10, 23, 

470 space_temperature) 

471 min_floor_df, max_floor_df = self.get_exceeded_temperature_hours( 

472 floor_df, 19, 

473 29, 0) 

474 min_ceiling_df, max_ceiling_df = ( 

475 self.get_exceeded_temperature_hours( 

476 ceiling_df, 

477 -14, 

478 5, space_temperature)) 

479 if not min_wall_df.empty: 

480 num_min_wall, hours_min_wall = ( 

481 self.calc_exceeded_temperature_hours( 

482 min_wall_df, space_temperature, 10)) 

483 local_discomfort_dict[space.guid]['wall'].update( 

484 {'min': {'count': num_min_wall, 

485 'hours': hours_min_wall}}) 

486 local_discomfort_overview.iloc[ 

487 -1, local_discomfort_overview.columns.get_loc( 

488 'wall_min')] = False 

489 min_wall_df = min_wall_df.rename( 

490 columns={'MinValue': 'wall_min'}) 

491 space_local_discomfort.update(min_wall_df) 

492 if not max_wall_df.empty: 

493 num_max_wall, hours_max_wall = ( 

494 self.calc_exceeded_temperature_hours( 

495 max_wall_df, space_temperature, 23)) 

496 local_discomfort_dict[space.guid]['wall'].update( 

497 {'max': {'count': num_max_wall, 

498 'hours': num_max_wall}}) 

499 local_discomfort_overview.iloc[ 

500 -1, local_discomfort_overview.columns.get_loc( 

501 'wall_max')] = False 

502 max_wall_df = max_wall_df.rename( 

503 columns={'MaxValue': 'wall_max'}) 

504 space_local_discomfort.update(max_wall_df) 

505 if not min_floor_df.empty: 

506 num_min_floor, hours_min_floor = ( 

507 self.calc_exceeded_temperature_hours( 

508 min_floor_df, 0, 19)) 

509 local_discomfort_dict[space.guid]['floor'].update( 

510 {'min': {'count': num_min_floor, 

511 'hours': hours_min_floor}}) 

512 local_discomfort_overview.iloc[ 

513 -1, local_discomfort_overview.columns.get_loc( 

514 'floor_min')] = False 

515 min_floor_df = min_floor_df.rename( 

516 columns={'MinValue': 'floor_min'}) 

517 space_local_discomfort.update(min_floor_df) 

518 if not max_floor_df.empty: 

519 num_max_floor, hours_max_floor = ( 

520 self.calc_exceeded_temperature_hours( 

521 max_floor_df, 0, 29)) 

522 local_discomfort_dict[space.guid]['floor'].update( 

523 {'max': {'count': num_max_floor, 

524 'hours': hours_max_floor}}) 

525 local_discomfort_overview.iloc[ 

526 -1, local_discomfort_overview.columns.get_loc( 

527 'floor_max')] = False 

528 max_floor_df = max_floor_df.rename( 

529 columns={'MaxValue': 'floor_max'}) 

530 space_local_discomfort.update(max_floor_df) 

531 if not min_ceiling_df.empty: 

532 num_min_ceiling, hours_min_ceiling = ( 

533 self.calc_exceeded_temperature_hours( 

534 min_ceiling_df, 0, 14)) 

535 local_discomfort_dict[space.guid]['ceiling'].update( 

536 {'min': {'count': num_min_ceiling, 

537 'hours': hours_min_ceiling}}) 

538 local_discomfort_overview.iloc[ 

539 -1, local_discomfort_overview.columns.get_loc( 

540 'ceiling_min')] = False 

541 min_ceiling_df = min_ceiling_df.rename( 

542 columns={'MinValue': 'ceiling_min'}) 

543 space_local_discomfort.update(min_ceiling_df) 

544 if not max_ceiling_df.empty: 

545 num_max_ceiling, hours_max_ceiling = ( 

546 self.calc_exceeded_temperature_hours( 

547 max_ceiling_df, 0, 5)) 

548 local_discomfort_dict[space.guid]['ceiling'].update( 

549 {'max': {'count': num_max_ceiling, 

550 'hours': hours_max_ceiling}}) 

551 local_discomfort_overview.iloc[ 

552 -1, local_discomfort_overview.columns.get_loc( 

553 'ceiling_max')] = False 

554 max_ceiling_df = max_ceiling_df.rename( 

555 columns={'MaxValue': 'ceiling_max'}) 

556 space_local_discomfort.update(max_ceiling_df) 

557 last_row_values = local_discomfort_overview.iloc[-1] 

558 all_true_except_space = all( 

559 last_row_values[col] for col in last_row_values.index if 

560 col != 'space') 

561 if all_true_except_space: 

562 self.logger.info(f'DIN EN 16798-1 NA (GER), ' 

563 f'limited local comfort check passed for space ' 

564 f'usage "{space.usage}" with ' 

565 f'guid "{space.guid}". ') 

566 else: 

567 space_local_discomfort = space_local_discomfort.dropna(how='all') 

568 space_local_discomfort.loc[:, 'space'] = (f"{space.usage}" 

569 f"_{space.guid}") 

570 space_local_discomfort['space_temperature'] = \ 

571 space_temperature.loc[n_persons_df > 0] 

572 space_local_discomfort = space_local_discomfort.dropna( 

573 how='all', axis=1) 

574 space_local_discomfort.to_csv(export_path / 

575 f'space_' 

576 f'{space.guid}_local_discomf.csv') 

577 failed_checks = [col for col in space_local_discomfort.columns 

578 if not col in ['space', 'space_temperature']] 

579 self.logger.warning(f'DIN EN 16798-1 NA (GER), limited local ' 

580 f'comfort check FAILED the checks ' 

581 f'{failed_checks} for space usage ' 

582 f'"{space.usage}" with ' 

583 f'guid "{space.guid}". Please check ' 

584 f'"space_{space.guid}_local_discomf.csv" ' 

585 f'for details.') 

586 with open(export_path / 'beps_local_discomfort.json', 'w+') as file: 

587 json.dump(local_discomfort_dict, file, indent=4) 

588 local_discomfort_overview.to_csv( 

589 export_path / 'local_discomfort_overview.csv') 

590 

591 def calc_exceeded_temperature_hours(self, df, reference, limit): 

592 """ 

593 Calculate temperature exceeding occurrence. 

594 

595 Returns a tuple, consisting of the number of timesteps that exceed 

596 the limit and the sum of all differences exceeding the limit. 

597 

598 Args: 

599 df: temperature dataframe 

600 reference: reference temperature value 

601 limit: limit temperature based on reference value 

602 

603 Returns: 

604 num_timesteps_exceeding, sum_difference_exceeding_limit 

605 

606 """ 

607 value_over_reference = abs(df.sub(reference, axis=0).dropna()) - limit 

608 return len(value_over_reference), value_over_reference.values.sum() 

609 

610 def get_exceeded_temperature_hours(self, df, min_limit, max_limit, 

611 ref_value): 

612 """ 

613 Get all entries of the dataframe where temperature is exceeded. 

614 Args: 

615 df: original dataframe 

616 min_limit: minimum temperature limit 

617 max_limit: maximum temperature limit 

618 ref_value: reference temperature 

619 

620 Returns: 

621 df with all entries below the min_limit, df_with all entries 

622 above the max_limit 

623 

624 """ 

625 

626 df_min = pd.DataFrame() 

627 df_max = pd.DataFrame() 

628 array = df.values 

629 mask_max = df.sub(ref_value, axis=0) > max_limit 

630 if mask_max.values.any(): 

631 filtered_array = np.where(mask_max, array, np.nan) 

632 max_values = [] 

633 for row in filtered_array: 

634 if not np.isnan(row).all(): 

635 max_values.append(np.nanmax(row)) 

636 else: 

637 max_values.append(np.nan) 

638 max_values = np.array(max_values) 

639 max_indices = np.where(~np.isnan(max_values))[0] 

640 df_max = pd.DataFrame(max_values[max_indices], 

641 index=df.index[max_indices], 

642 columns=['MaxValue']) 

643 mask_min = df.sub(ref_value, axis=0) < min_limit 

644 if mask_min.values.any(): 

645 filtered_array = np.where(mask_min, array, np.nan) 

646 min_values = [] 

647 for row in filtered_array: 

648 if not np.isnan(row).all(): 

649 min_values.append(np.nanmin(row)) 

650 else: 

651 min_values.append(np.nan) 

652 min_values = np.array(min_values) 

653 min_indices = np.where(~np.isnan(min_values))[0] 

654 df_min = pd.DataFrame(min_values[min_indices], 

655 index=df.index[min_indices], 

656 columns=['MinValue']) 

657 

658 return df_min, df_max 

659 

660 @staticmethod 

661 def rename_duplicates(dictionary): 

662 value_counts = {} 

663 renamed_dict = {} 

664 for key, value in dictionary.items(): 

665 if value in value_counts: 

666 value_counts[value] += 1 

667 new_value = f"{value}_{value_counts[value]}" 

668 else: 

669 value_counts[value] = 1 

670 new_value = value 

671 

672 renamed_dict[key] = new_value 

673 return renamed_dict 

674 

675 def rename_zone_usage(self, zone_dict, zone_dict_ifc_names, rename_keys, 

676 sim_results_path, 

677 rename_duplicates=False): 

678 new_zone_names = {} 

679 for key in zone_dict.keys(): 

680 new_name = None 

681 # prepare room names 

682 if '-' in zone_dict_ifc_names[key]['Name']: 

683 room_name = zone_dict_ifc_names[key]['Name'].split('-')[ 

684 1] 

685 if '_' in room_name: 

686 room_name = room_name.split('_')[0] 

687 else: 

688 room_name = zone_dict_ifc_names[key]['Name'] 

689 # prepare storey names 

690 # rename storeys using short versions 

691 # does not consider all naming conventions yet, needs to be extended 

692 if '_' in zone_dict_ifc_names[key]['StoreyName']: 

693 storey_name = \ 

694 zone_dict_ifc_names[key]['StoreyName'].split( 

695 '_')[0] 

696 else: 

697 storey_name = zone_dict_ifc_names[key]['StoreyName'] 

698 if storey_name.upper() == 'Erdgeschoss'.upper(): 

699 storey_name = 'EG' 

700 elif storey_name.upper() == 'Dachgeschoss'.upper(): 

701 storey_name = 'OG' 

702 elif storey_name.upper() == 'UNTERGESCHOSS': 

703 storey_name = 'UG' 

704 # generate new name based on storey and space name 

705 for key2 in rename_keys.keys(): 

706 if zone_dict[key] == key2: 

707 zone_dict[key] = rename_keys[key2] 

708 if zone_dict_ifc_names[key]['ZoneUsage'] == key2: 

709 new_name = (f"{storey_name}-{int(room_name):02d}" 

710 f" {rename_keys[key2]}") 

711 if not new_name: 

712 new_name = (f"{storey_name}-{int(room_name):02d}" 

713 f" {zone_dict_ifc_names[key]['ZoneUsage']}") 

714 # update names 

715 new_zone_names.update({key: new_name}) 

716 # store new short rook keys based on storey + space name 

717 with open(sim_results_path / self.prj_name / 'short_room_keys.json', 

718 'w+') as f: 

719 json.dump(new_zone_names, f, indent=4) 

720 # rename duplicate space names (add enumeration) to prevent overwriting 

721 if rename_duplicates: 

722 zone_usage = self.rename_duplicates(zone_dict) 

723 new_zone_names = self.rename_duplicates(new_zone_names) 

724 else: 

725 zone_usage = zone_dict 

726 return zone_usage, new_zone_names 

727 

728 @staticmethod 

729 def pmv_plot(df, save_path, file_name): 

730 PlotBEPSResults.plot_dataframe(df, save_path=save_path, 

731 file_name=file_name, 

732 x_axis_title="Date", 

733 y_axis_title="PMV") 

734 

735 def apply_en16798_to_all_zones(self, df, zone_dict, export_path, 

736 use_NA=True): 

737 """Generate EN 16798 diagrams for all thermal zones. 

738 

739 Args: 

740 df: input dataframe 

741 zone_dict: zone name dictionary 

742 export_path: export path for result plots 

743 use_NA: use national appendix (Germany) 

744 

745 Returns: 

746 dataframe holding the adaptive comfort categories, 

747 dataframe holding the comfort categories for occupied hours, 

748 dataframe holding the number of occupied hours per category 

749 """ 

750 if use_NA: 

751 add_NA_str = ' NA (GER)' 

752 else: 

753 add_NA_str = '' 

754 logger.info(f"Plot DIN EN 16798{add_NA_str} diagrams for all zones ...") 

755 

756 cat_analysis = pd.DataFrame() 

757 cat_analysis_occ = pd.DataFrame() 

758 cat_analysis_occ_hours = pd.DataFrame() 

759 for guid, room_name in zone_dict.items(): 

760 if not any(df.filter(like=guid)): 

761 continue 

762 temp_cat_analysis = None 

763 temp_cat_analysis_occ = None 

764 temp_cat_analysis_occ_hours = None 

765 if use_NA: 

766 (temp_cat_analysis, temp_cat_analysis_occ, 

767 temp_cat_analysis_occ_hours) = ( 

768 self.plot_en16798_adaptive_count_NA( 

769 df, guid, room_name, export_path)) 

770 cat_analysis_occ_hours = pd.concat([cat_analysis_occ_hours, 

771 temp_cat_analysis_occ_hours]) 

772 else: