Coverage for bim2sim / plugins / PluginOpenFOAM / bim2sim_openfoam / task / set_boundary_conditions.py: 0%

1from collections import OrderedDict 

2 

3import pandas as pd 

4 

5from bim2sim.elements.mapping.units import ureg 

6from bim2sim.plugins.PluginEnergyPlus.bim2sim_energyplus.utils import \ 

7 PostprocessingUtils 

8from bim2sim.plugins.PluginOpenFOAM.bim2sim_openfoam.openfoam_elements.openfoam_base_boundary_conditions import \ 

9 OpenFOAMBaseBoundaryFields 

10from bim2sim.plugins.PluginOpenFOAM.bim2sim_openfoam.utils.openfoam_utils import \ 

11 OpenFOAMUtils as of_utils 

12from bim2sim.tasks.base import ITask 

13from bim2sim.utilities.common_functions import filter_elements 

14from butterfly import boundaryRadiationProperties, alphat, aoa, \ 

15 g_radiation, idefault, k, nut, omega, p, p_rgh, qr, T, U, foamfile 

16 

17 

18class SetOpenFOAMBoundaryConditions(ITask): 

19 """This ITask initializes the OpenFOAM Setup. 

20 """ 

21 

22 reads = ('openfoam_elements', 'openfoam_case') 

23 touches = ('openfoam_case', 'openfoam_elements') 

24 

25 def __init__(self, playground): 

26 super().__init__(playground) 

27 self.default_surface_names = ['Back', 'Bottom', 'Front', 'Top', 'Left', 

28 'Right'] 

29 

30 def run(self, openfoam_elements, openfoam_case): 

31 self.assign_ep_results( 

32 openfoam_elements, openfoam_case, 

33 add_floor_heating=self.playground.sim_settings.add_floorheating) 

34 self.init_boundary_conditions(openfoam_case, openfoam_elements) 

35 self.add_fvOptions_for_heating(openfoam_case, openfoam_elements) 

36 

37 return openfoam_case, openfoam_elements 

38 

39 def assign_ep_results(self, openfoam_elements, openfoam_case, 

40 add_floor_heating=False): 

41 stl_bounds = filter_elements(openfoam_elements, 'StlBound') 

42 timestep_df = openfoam_case.timestep_df 

43 openfoam_case.current_zone.zone_heat_conduction = 0 

44 openfoam_case.current_zone.air_temp = timestep_df[ 

45 openfoam_case.current_zone.guid.upper() + 

46 ':' + ( 

47 'Zone Mean Air Temperature [C](' 

48 'Hourly)')] + 273.15 

49 for bound in stl_bounds: 

50 bound.read_boundary_conditions(timestep_df, openfoam_case.current_zone.air_temp) 

51 openfoam_case.current_zone.zone_heat_conduction += ( 

52 bound.bound_area * bound.heat_flux) 

53 # todo: add gains from solar radiation 

54 # compute internal gains 

55 people = filter_elements(openfoam_elements, 'People') 

56 # todo: add other internal gains from equipment etc. 

57 openfoam_case.internal_gains = 0 

58 for peo in people: 

59 openfoam_case.internal_gains += peo.power 

60 openfoam_case.required_heating_power = ( 

61 openfoam_case.current_zone.zone_heat_conduction) 

62 if self.playground.sim_settings.level_heat_balance: 

63 openfoam_case.required_heating_power += openfoam_case.internal_gains 

64 # todo: consider radiation from windows once implemented 

65 if openfoam_case.required_heating_power > 0: 

66 openfoam_case.required_cooling_power = ( 

67 openfoam_case.required_heating_power) 

68 openfoam_case.required_heating_power = 0 

69 self.logger.warning(f'Heat balance cannot be leveled. Internal ' 

70 f'gains are higher than the heating ' 

71 f'demand. Required heating power is set to ' 

72 f'zero, cooling power is required of ' 

73 f'{openfoam_case.required_cooling_power}W.' 

74 f'The the room may heat up ' 

75 f'eventually due to high internal gains ' 

76 f'if no air conditioning system is ' 

77 f'available.') 

78 if add_floor_heating: 

79 total_floor_area = 0 

80 for bound in stl_bounds: 

81 # reduce calculated floor heating by floor heat losses 

82 # self.current_zone.floor_heating_qr = \ 

83 # (timestep_df[(f"{self.current_zone.guid.upper()} IDEAL LOADS AIR SYSTEM:Zone " 

84 # f"Ideal Loads Zone Total Heating Rate [W](Hourly)")] / 

85 # self.current_zone.net_area.m) 

86 # todo: only works for spaces with a single floor surface 

87 if any(s in bound.bound_element_type for s in ['Floor', 

88 'GroundFloor']): 

89 total_floor_area += bound.bound_area 

90 openfoam_case.current_zone.abs_floor_heating_qr = \ 

91 abs(openfoam_case.required_heating_power / 

92 total_floor_area) 

93 for bound in stl_bounds: 

94 if any(s in bound.bound_element_type for s in ['Floor', 

95 'GroundFloor']): 

96 bound.temperature_org = bound.temperature 

97 bound.heat_flux_org = bound.heat_flux 

98 bound.temperature = 30 

99 # previous heat flux of the boundary has to be neglegted. 

100 # the previous bound heat flux needs to be added to the 

101 # total floor heating heat flux. 

102 bound.heat_flux = abs( 

103 openfoam_case.current_zone.abs_floor_heating_qr + 

104 bound.heat_flux) 

105 

106 def init_boundary_conditions(self, openfoam_case, openfoam_elements): 

107 stl_bounds, heaters, air_terminals, furniture, people = \ 

108 of_utils.split_openfoam_elements(openfoam_elements) 

109 for bound in stl_bounds: 

110 bound.set_boundary_conditions( 

111 no_heatloss=self.playground.sim_settings.ignore_heatloss) 

112 for heater in heaters: 

113 heating_power_each = (abs(openfoam_case.required_heating_power) / 

114 len(heaters)) 

115 # if openfoam_case.radiation_model == 'noRadiation': 

116 # heater_radiation = 0 

117 # else: 

118 if self.playground.sim_settings.heater_radiation < 1e-4: 

119 heater_radiation = 0 

120 else: 

121 heater_radiation = self.playground.sim_settings.heater_radiation 

122 heater.set_boundary_conditions( 

123 heating_power_each, heater_radiation) 

124 vol_per_inlet = 0 

125 vol_per_outlet = 0 

126 # calculate volumetric flow rate in l/s according to 

127 # DIN EN 16798-1:2022-03, Table B.6/B.7 + Table NA.6/NA.7 

128 # building with high emissions, air quality cat 1: 2 l/s/m2 

129 # building with low emissions, air quality cat 2: 0.7 l/s/m2 

130 # building with very low emissions, air quality cat 2: 0.35 l/s/m2 

131 # volumetric flow per person, air quality cat 2: 7 l/s/person 

132 total_volumetric_flow_l_per_s = (openfoam_case.floor_area * 2.0 + 7 * 

133 len(people)) 

134 dt_cooling = 0 

135 num_inlets = len( 

136 [i for i in air_terminals if 'INLET' in i.air_type.upper()]) 

137 if num_inlets > 0: 

138 vol_per_inlet = total_volumetric_flow_l_per_s / num_inlets 

139 cooling_power_each = (abs( 

140 openfoam_case.required_cooling_power)/num_inlets) * ureg.watt 

141 dt_cooling = cooling_power_each / (1004.5 * (ureg.joule)/(ureg.kg*ureg.kelvin) * 

142 1.204*(ureg.kg/ureg.meter**3) * 

143 vol_per_inlet *(ureg.l/ureg.s)) 

144 dt_cooling = dt_cooling.to(ureg.kelvin).m 

145 self.logger.info(f"Required delta temperature of {dt_cooling}K is " 

146 f"set for each inlet.") 

147 if dt_cooling > 6: 

148 self.logger.warning(f"The required delta temperature of " 

149 f"{dt_cooling}K is {dt_cooling-6}K larger " 

150 f"than a comfortable limit for delta " 

151 f"temperature of 6K. To avoid local " 

152 f"discomfort, please increase the airflow " 

153 f"and the number of air inlets.") 

154 num_outlets = len( 

155 [i for i in air_terminals if 'OUTLET' in i.air_type.upper()]) 

156 if num_outlets > 0: 

157 vol_per_outlet = total_volumetric_flow_l_per_s / num_outlets 

158 for air_terminal in air_terminals: 

159 if 'INLET' in air_terminal.air_type.upper(): 

160 volumetric_flow_l_per_s = vol_per_inlet 

161 applicable_delta = dt_cooling 

162 else: 

163 volumetric_flow_l_per_s = vol_per_outlet 

164 applicable_delta = 0 

165 air_terminal.set_boundary_conditions( 

166 openfoam_case.current_zone.air_temp - applicable_delta, 

167 volumetric_flow_l_per_s) 

168 for furn in furniture: 

169 furn.set_boundary_conditions() 

170 for person in people: 

171 person.set_boundary_conditions() 

172 for body_part in person.body_parts_dict.values(): 

173 body_part.set_boundary_conditions() 

174 if people: 

175 # export person dataframe for documentation of surface 

176 # temperatures and surface area. 

177 person_df = pd.DataFrame( 

178 [[key, 

179 part.area, 

180 part.temperature, 

181 part.hr_hc, 

182 part.heat_flux, 

183 part.area * part.heat_flux] 

184 for key, part in people[0].body_parts_dict.items()], 

185 columns=['PartName', 'Area', 'Temperature', 'hr_hc', 

186 'HeatFlux', 'Power']) 

187 person_df.to_csv( 

188 openfoam_case.openfoam_dir / str(people[0].solid_name + '.csv')) 

189 

190 # todo: move initial boundary condition settings to OpenFOAM element 

191 # classes. 

192 self.create_alphat(openfoam_case, openfoam_elements) 

193 self.create_AoA(openfoam_case, openfoam_elements) 

194 self.create_G(openfoam_case, openfoam_elements) 

195 self.create_IDefault(openfoam_case, openfoam_elements) 

196 self.create_k(openfoam_case, openfoam_elements) 

197 self.create_nut(openfoam_case, openfoam_elements) 

198 self.create_omega(openfoam_case, openfoam_elements) 

199 self.create_p(openfoam_case, openfoam_elements) 

200 self.create_p_rgh(openfoam_case, openfoam_elements) 

201 self.create_qr(openfoam_case, openfoam_elements) 

202 self.create_T(openfoam_case, openfoam_elements) 

203 self.create_U(openfoam_case, openfoam_elements) 

204 self.create_boundaryRadiationProperties(openfoam_case, 

205 openfoam_elements) 

206 

207 @staticmethod 

208 def create_alphat(openfoam_case, openfoam_elements): 

209 stl_bounds, heaters, air_terminals, furniture, people = \ 

210 of_utils.split_openfoam_elements(openfoam_elements) 

211 openfoam_case.alphat = alphat.Alphat() 

212 openfoam_case.alphat.values['boundaryField'] = {} 

213 openfoam_case.alphat.values['dimensions'] = '[1 -1 -1 0 0 0 0]' 

214 for bound in stl_bounds: 

215 openfoam_case.alphat.values['boundaryField'].update( 

216 {bound.solid_name: bound.alphat}) 

217 

218 for heater in heaters: 

219 # openfoam_case.alphat.values['boundaryField'].update( 

220 # {heater.porous_media.solid_name: heater.porous_media.alphat}) 

221 openfoam_case.alphat.values['boundaryField'].update( 

222 { 

223 heater.heater_surface.solid_name: heater.heater_surface.alphat}) 

224 for air_terminal in air_terminals: 

225 if air_terminal.diffuser.solid_name: 

226 openfoam_case.alphat.values['boundaryField'].update( 

227 {air_terminal.diffuser.solid_name: air_terminal.diffuser.alphat}) 

228 if air_terminal.source_sink.solid_name: 

229 openfoam_case.alphat.values['boundaryField'].update( 

230 {air_terminal.source_sink.solid_name: 

231 air_terminal.source_sink.alphat}) 

232 if air_terminal.box.solid_name: 

233 openfoam_case.alphat.values['boundaryField'].update( 

234 {air_terminal.box.solid_name: air_terminal.box.alphat}) 

235 for furn in furniture: 

236 openfoam_case.alphat.values['boundaryField'].update( 

237 {furn.solid_name: furn.alphat}) 

238 for person in people: 

239 for body_part in person.body_parts_dict.values(): 

240 openfoam_case.alphat.values['boundaryField'].update( 

241 {body_part.solid_name: body_part.alphat}) 

242 default_name_list = openfoam_case.default_surface_names 

243 for name in default_name_list: 

244 openfoam_case.alphat.values['boundaryField'].update( 

245 {name: OpenFOAMBaseBoundaryFields().alphat 

246 }) 

247 

248 openfoam_case.alphat.save(openfoam_case.openfoam_dir) 

249 

250 @staticmethod 

251 def create_AoA(openfoam_case, openfoam_elements): 

252 stl_bounds, heaters, air_terminals, furniture, people = \ 

253 of_utils.split_openfoam_elements(openfoam_elements) 

254 openfoam_case.aoa = aoa.AoA() 

255 openfoam_case.aoa.values['boundaryField'] = {} 

256 for bound in stl_bounds: 

257 openfoam_case.aoa.values['boundaryField'].update( 

258 {bound.solid_name: bound.aoa}) 

259 for heater in heaters: 

260 # openfoam_case.aoa.values['boundaryField'].update( 

261 # {heater.porous_media.solid_name: heater.porous_media.aoa}) 

262 openfoam_case.aoa.values['boundaryField'].update( 

263 {heater.heater_surface.solid_name: heater.heater_surface.aoa}) 

264 for air_terminal in air_terminals: 

265 if air_terminal.diffuser.solid_name: 

266 openfoam_case.aoa.values['boundaryField'].update( 

267 {air_terminal.diffuser.solid_name: air_terminal.diffuser.aoa}) 

268 if air_terminal.source_sink.solid_name: 

269 openfoam_case.aoa.values['boundaryField'].update( 

270 {air_terminal.source_sink.solid_name: 

271 air_terminal.source_sink.aoa}) 

272 if air_terminal.box.solid_name: 

273 openfoam_case.aoa.values['boundaryField'].update({ 

274 air_terminal.box.solid_name: air_terminal.box.aoa 

275 }) 

276 for furn in furniture: 

277 openfoam_case.aoa.values['boundaryField'].update( 

278 {furn.solid_name: furn.aoa}) 

279 for person in people: 

280 for body_part in person.body_parts_dict.values(): 

281 openfoam_case.aoa.values['boundaryField'].update( 

282 {body_part.solid_name: body_part.aoa}) 

283 default_name_list = openfoam_case.default_surface_names 

284 for name in default_name_list: 

285 openfoam_case.aoa.values['boundaryField'].update( 

286 {name: OpenFOAMBaseBoundaryFields().aoa} 

287 ) 

288 openfoam_case.aoa.save(openfoam_case.openfoam_dir) 

289 

290 @staticmethod 

291 def create_G(openfoam_case, openfoam_elements): 

292 stl_bounds, heaters, air_terminals, furniture, people = \ 

293 of_utils.split_openfoam_elements(openfoam_elements) 

294 openfoam_case.g_radiation = g_radiation.G_radiation() 

295 openfoam_case.g_radiation.values['boundaryField'] = {} 

296 

297 for bound in stl_bounds: 

298 openfoam_case.g_radiation.values['boundaryField'].update( 

299 {bound.solid_name: bound.g_radiation}) 

300 for heater in heaters: 

301 # openfoam_case.g_radiation.values['boundaryField'].update( 

302 # {heater.porous_media.solid_name: 

303 # heater.porous_media.g_radiation}) 

304 openfoam_case.g_radiation.values['boundaryField'].update( 

305 {heater.heater_surface.solid_name: 

306 heater.heater_surface.g_radiation}) 

307 for air_terminal in air_terminals: 

308 if air_terminal.diffuser.solid_name: 

309 openfoam_case.g_radiation.values['boundaryField'].update( 

310 {air_terminal.diffuser.solid_name: air_terminal.diffuser.g_radiation}) 

311 if air_terminal.source_sink.solid_name: 

312 openfoam_case.g_radiation.values['boundaryField'].update( 

313 {air_terminal.source_sink.solid_name: 

314 air_terminal.source_sink.g_radiation}) 

315 if air_terminal.box.solid_name: 

316 openfoam_case.g_radiation.values['boundaryField'].update( 

317 {air_terminal.box.solid_name: air_terminal.box.g_radiation 

318 }) 

319 for furn in furniture: 

320 openfoam_case.g_radiation.values['boundaryField'].update( 

321 {furn.solid_name: furn.g_radiation}) 

322 for person in people: 

323 for body_part in person.body_parts_dict.values(): 

324 openfoam_case.g_radiation.values['boundaryField'].update( 

325 {body_part.solid_name: body_part.g_radiation}) 

326 default_name_list = openfoam_case.default_surface_names 

327 for name in default_name_list: 

328 openfoam_case.g_radiation.values['boundaryField'].update( 

329 {name: OpenFOAMBaseBoundaryFields().g_radiation}) 

330 openfoam_case.g_radiation.save(openfoam_case.openfoam_dir) 

331 

332 @staticmethod 

333 def create_IDefault(openfoam_case, openfoam_elements): 

334 stl_bounds, heaters, air_terminals, furniture, people = \ 

335 of_utils.split_openfoam_elements(openfoam_elements) 

336 openfoam_case.idefault = idefault.IDefault() 

337 openfoam_case.idefault.values['boundaryField'] = {} 

338 

339 for bound in stl_bounds: 

340 openfoam_case.idefault.values['boundaryField'].update( 

341 {bound.solid_name: bound.idefault}) 

342 for heater in heaters: 

343 # openfoam_case.idefault.values['boundaryField'].update( 

344 # {heater.porous_media.solid_name: 

345 # heater.porous_media.idefault}) 

346 openfoam_case.idefault.values['boundaryField'].update( 

347 {heater.heater_surface.solid_name: 

348 heater.heater_surface.idefault}) 

349 for air_terminal in air_terminals: 

350 if air_terminal.diffuser.solid_name: 

351 openfoam_case.idefault.values['boundaryField'].update({ 

352 air_terminal.diffuser.solid_name: air_terminal.diffuser.idefault}) 

353 if air_terminal.source_sink.solid_name: 

354 openfoam_case.idefault.values['boundaryField'].update({ 

355 air_terminal.source_sink.solid_name: 

356 air_terminal.source_sink.idefault}) 

357 if air_terminal.box.solid_name: 

358 openfoam_case.idefault.values['boundaryField'].update({ 

359 air_terminal.box.solid_name: air_terminal.box.idefault 

360 }) 

361 for furn in furniture: 

362 openfoam_case.idefault.values['boundaryField'].update( 

363 {furn.solid_name: furn.idefault}) 

364 for person in people: 

365 for body_part in person.body_parts_dict.values(): 

366 openfoam_case.idefault.values['boundaryField'].update( 

367 {body_part.solid_name: body_part.idefault}) 

368 default_name_list = openfoam_case.default_surface_names 

369 for name in default_name_list: 

370 openfoam_case.idefault.values['boundaryField'].update( 

371 {name: OpenFOAMBaseBoundaryFields().idefault}) 

372 openfoam_case.idefault.save(openfoam_case.openfoam_dir) 

373 

374 @staticmethod 

375 def create_k(openfoam_case, openfoam_elements): 

376 stl_bounds, heaters, air_terminals, furniture, people = \ 

377 of_utils.split_openfoam_elements(openfoam_elements) 

378 openfoam_case.k = k.K() 

379 openfoam_case.k.values['boundaryField'] = {} 

380 

381 for bound in stl_bounds: 

382 openfoam_case.k.values['boundaryField'].update( 

383 {bound.solid_name: bound.k}) 

384 for heater in heaters: 

385 # openfoam_case.k.values['boundaryField'].update( 

386 # {heater.porous_media.solid_name: 

387 # heater.porous_media.k}) 

388 openfoam_case.k.values['boundaryField'].update( 

389 {heater.heater_surface.solid_name: 

390 heater.heater_surface.k}) 

391 for air_terminal in air_terminals: 

392 if air_terminal.diffuser.solid_name: 

393 openfoam_case.k.values['boundaryField'].update( 

394 {air_terminal.diffuser.solid_name: air_terminal.diffuser.k}) 

395 if air_terminal.source_sink.solid_name: 

396 openfoam_case.k.values['boundaryField'].update({ 

397 air_terminal.source_sink.solid_name: 

398 air_terminal.source_sink.k}) 

399 if air_terminal.box.solid_name: 

400 openfoam_case.k.values['boundaryField'].update({ 

401 air_terminal.box.solid_name: air_terminal.box.k 

402 }) 

403 for furn in furniture: 

404 openfoam_case.k.values['boundaryField'].update( 

405 {furn.solid_name: furn.k}) 

406 for person in people: 

407 for body_part in person.body_parts_dict.values(): 

408 openfoam_case.k.values['boundaryField'].update( 

409 {body_part.solid_name: body_part.k}) 

410 default_name_list = openfoam_case.default_surface_names 

411 for name in default_name_list: 

412 openfoam_case.k.values['boundaryField'].update( 

413 {name: OpenFOAMBaseBoundaryFields().k}) 

414 openfoam_case.k.save(openfoam_case.openfoam_dir) 

415 

416 @staticmethod 

417 def create_nut(openfoam_case, openfoam_elements): 

418 stl_bounds, heaters, air_terminals, furniture, people = \ 

419 of_utils.split_openfoam_elements(openfoam_elements) 

420 openfoam_case.nut = nut.Nut() 

421 openfoam_case.nut.values['boundaryField'] = {} 

422 

423 for bound in stl_bounds: 

424 openfoam_case.nut.values['boundaryField'].update( 

425 {bound.solid_name: bound.nut}) 

426 for heater in heaters: 

427 # openfoam_case.nut.values['boundaryField'].update( 

428 # {heater.porous_media.solid_name: 

429 # heater.porous_media.nut}) 

430 openfoam_case.nut.values['boundaryField'].update( 

431 {heater.heater_surface.solid_name: 

432 heater.heater_surface.nut}) 

433 for air_terminal in air_terminals: 

434 if air_terminal.diffuser.solid_name: 

435 openfoam_case.nut.values['boundaryField'].update( 

436 {air_terminal.diffuser.solid_name: air_terminal.diffuser.nut}) 

437 if air_terminal.source_sink.solid_name: 

438 openfoam_case.nut.values['boundaryField'].update({ 

439 air_terminal.source_sink.solid_name: 

440 air_terminal.source_sink.nut}) 

441 if air_terminal.box.solid_name: 

442 openfoam_case.nut.values['boundaryField'].update({ 

443 air_terminal.box.solid_name: air_terminal.box.nut 

444 }) 

445 for furn in furniture: 

446 openfoam_case.nut.values['boundaryField'].update( 

447 {furn.solid_name: furn.nut}) 

448 for person in people: 

449 for body_part in person.body_parts_dict.values(): 

450 openfoam_case.nut.values['boundaryField'].update( 

451 {body_part.solid_name: body_part.nut}) 

452 default_name_list = openfoam_case.default_surface_names 

453 for name in default_name_list: 

454 openfoam_case.nut.values['boundaryField'].update( 

455 {name: OpenFOAMBaseBoundaryFields().nut}) 

456 openfoam_case.nut.save(openfoam_case.openfoam_dir) 

457 

458 @staticmethod 

459 def create_omega(openfoam_case, openfoam_elements): 

460 stl_bounds, heaters, air_terminals, furniture, people = \ 

461 of_utils.split_openfoam_elements(openfoam_elements) 

462 openfoam_case.omega = omega.Omega() 

463 openfoam_case.omega.values['boundaryField'] = {} 

464 

465 for bound in stl_bounds: 

466 openfoam_case.omega.values['boundaryField'].update( 

467 {bound.solid_name: bound.omega}) 

468 for heater in heaters: 

469 # openfoam_case.omega.values['boundaryField'].update( 

470 # {heater.porous_media.solid_name: 

471 # heater.porous_media.omega}) 

472 openfoam_case.omega.values['boundaryField'].update( 

473 {heater.heater_surface.solid_name: 

474 heater.heater_surface.omega}) 

475 for air_terminal in air_terminals: 

476 if air_terminal.diffuser.solid_name: 

477 openfoam_case.omega.values['boundaryField'].update( 

478 {air_terminal.diffuser.solid_name: air_terminal.diffuser.omega}) 

479 if air_terminal.source_sink.solid_name: 

480 openfoam_case.omega.values['boundaryField'].update({ 

481 air_terminal.source_sink.solid_name: 

482 air_terminal.source_sink.omega}) 

483 if air_terminal.box.solid_name: 

484 openfoam_case.omega.values['boundaryField'].update({ 

485 air_terminal.box.solid_name: air_terminal.box.omega 

486 }) 

487 for furn in furniture: 

488 openfoam_case.omega.values['boundaryField'].update( 

489 {furn.solid_name: furn.omega}) 

490 for person in people: 

491 for body_part in person.body_parts_dict.values(): 

492 openfoam_case.omega.values['boundaryField'].update( 

493 {body_part.solid_name: body_part.omega}) 

494 default_name_list = openfoam_case.default_surface_names 

495 for name in default_name_list: 

496 openfoam_case.omega.values['boundaryField'].update( 

497 {name: OpenFOAMBaseBoundaryFields().omega}) 

498 openfoam_case.omega.save(openfoam_case.openfoam_dir) 

499 

500 @staticmethod 

501 def create_p(openfoam_case, openfoam_elements): 

502 stl_bounds, heaters, air_terminals, furniture, people = \ 

503 of_utils.split_openfoam_elements(openfoam_elements) 

504 openfoam_case.p = p.P() 

505 openfoam_case.p.values['boundaryField'] = {} 

506 openfoam_case.p.values['internalField'] = 'uniform 101325' 

507 openfoam_case.p.values['dimensions'] = '[1 -1 -2 0 0 0 0]' 

508 

509 for bound in stl_bounds: 

510 openfoam_case.p.values['boundaryField'].update( 

511 {bound.solid_name: bound.p}) 

512 for heater in heaters: 

513 # openfoam_case.p.values['boundaryField'].update( 

514 # {heater.porous_media.solid_name: 

515 # heater.porous_media.p}) 

516 openfoam_case.p.values['boundaryField'].update( 

517 {heater.heater_surface.solid_name: 

518 heater.heater_surface.p}) 

519 for air_terminal in air_terminals: 

520 if air_terminal.diffuser.solid_name: 

521 openfoam_case.p.values['boundaryField'].update( 

522 {air_terminal.diffuser.solid_name: air_terminal.diffuser.p}) 

523 if air_terminal.source_sink.solid_name: 

524 openfoam_case.p.values['boundaryField'].update({ 

525 air_terminal.source_sink.solid_name: 

526 air_terminal.source_sink.p}) 

527 if air_terminal.box.solid_name: 

528 openfoam_case.p.values['boundaryField'].update({ 

529 air_terminal.box.solid_name: air_terminal.box.p 

530 }) 

531 for furn in furniture: 

532 openfoam_case.p.values['boundaryField'].update( 

533 {furn.solid_name: furn.p}) 

534 for person in people: 

535 for body_part in person.body_parts_dict.values(): 

536 openfoam_case.p.values['boundaryField'].update( 

537 {body_part.solid_name: body_part.p}) 

538 default_name_list = openfoam_case.default_surface_names 

539 for name in default_name_list: 

540 openfoam_case.p.values['boundaryField'].update( 

541 {name: OpenFOAMBaseBoundaryFields().p}) 

542 openfoam_case.p.save(openfoam_case.openfoam_dir) 

543 

544 def create_p_rgh(self, openfoam_case, openfoam_elements): 

545 stl_bounds, heaters, air_terminals, furniture, people = \ 

546 of_utils.split_openfoam_elements(openfoam_elements) 

547 openfoam_case.p_rgh = p_rgh.P_rgh() 

548 openfoam_case.p_rgh.values['boundaryField'] = {} 

549 openfoam_case.p_rgh.values['internalField'] = 'uniform 101325' 

550 openfoam_case.p_rgh.values['dimensions'] = '[1 -1 -2 0 0 0 0]' 

551 

552 for bound in stl_bounds: 

553 openfoam_case.p_rgh.values['boundaryField'].update( 

554 {bound.solid_name: bound.p_rgh}) 

555 for heater in heaters: 

556 # openfoam_case.p_rgh.values['boundaryField'].update( 

557 # {heater.porous_media.solid_name: 

558 # heater.porous_media.p_rgh}) 

559 openfoam_case.p_rgh.values['boundaryField'].update( 

560 {heater.heater_surface.solid_name: 

561 heater.heater_surface.p_rgh}) 

562 for air_terminal in air_terminals: 

563 if air_terminal.diffuser.solid_name: 

564 openfoam_case.p_rgh.values['boundaryField'].update( 

565 {air_terminal.diffuser.solid_name: air_terminal.diffuser.p_rgh}) 

566 if air_terminal.source_sink.solid_name: 

567 openfoam_case.p_rgh.values['boundaryField'].update({ 

568 air_terminal.source_sink.solid_name: 

569 air_terminal.source_sink.p_rgh}) 

570 if air_terminal.box.solid_name: 

571 openfoam_case.p_rgh.values['boundaryField'].update({ 

572 air_terminal.box.solid_name: air_terminal.box.p_rgh 

573 }) 

574 for furn in furniture: 

575 openfoam_case.p_rgh.values['boundaryField'].update( 

576 {furn.solid_name: furn.p_rgh}) 

577 for person in people: 

578 for body_part in person.body_parts_dict.values(): 

579 openfoam_case.p_rgh.values['boundaryField'].update( 

580 {body_part.solid_name: body_part.p_rgh}) 

581 default_name_list = openfoam_case.default_surface_names 

582 for name in default_name_list: 

583 openfoam_case.p_rgh.values['boundaryField'].update( 

584 {name: OpenFOAMBaseBoundaryFields().p_rgh}) 

585 openfoam_case.p_rgh.save(openfoam_case.openfoam_dir) 

586 

587 @staticmethod 

588 def create_qr(openfoam_case, openfoam_elements): 

589 stl_bounds, heaters, air_terminals, furniture, people = \ 

590 of_utils.split_openfoam_elements(openfoam_elements) 

591 openfoam_case.qr = qr.Qr() 

592 openfoam_case.qr.values['boundaryField'] = {} 

593 

594 for bound in stl_bounds: 

595 openfoam_case.qr.values['boundaryField'].update( 

596 {bound.solid_name: bound.qr}) 

597 for heater in heaters: 

598 openfoam_case.qr.values['boundaryField'].update( 

599 {heater.porous_media.solid_name: 

600 heater.porous_media.qr}) 

601 openfoam_case.qr.values['boundaryField'].update( 

602 {heater.heater_surface.solid_name: 

603 heater.heater_surface.qr}) 

604 for air_terminal in air_terminals: 

605 if air_terminal.diffuser.solid_name: 

606 openfoam_case.qr.values['boundaryField'].update( 

607 {air_terminal.diffuser.solid_name: air_terminal.diffuser.qr}) 

608 if air_terminal.source_sink.solid_name: 

609 openfoam_case.qr.values['boundaryField'].update({ 

610 air_terminal.source_sink.solid_name: 

611 air_terminal.source_sink.qr}) 

612 if air_terminal.box.solid_name: 

613 openfoam_case.qr.values['boundaryField'].update({ 

614 air_terminal.box.solid_name: air_terminal.box.qr 

615 }) 

616 for furn in furniture: 

617 openfoam_case.qr.values['boundaryField'].update( 

618 {furn.solid_name: furn.qr}) 

619 for person in people: 

620 for body_part in person.body_parts_dict.values(): 

621 openfoam_case.qr.values['boundaryField'].update( 

622 {body_part.solid_name: body_part.qr}) 

623 default_name_list = openfoam_case.default_surface_names 

624 for name in default_name_list: 

625 openfoam_case.qr.values['boundaryField'].update( 

626 {name: OpenFOAMBaseBoundaryFields().qr}) 

627 openfoam_case.qr.save(openfoam_case.openfoam_dir) 

628 

629 @staticmethod 

630 def create_T(openfoam_case, openfoam_elements): 

631 default_name_list = openfoam_case.default_surface_names 

632 

633 stl_bounds, heaters, air_terminals, furniture, people = \ 

634 of_utils.split_openfoam_elements(openfoam_elements) 

635 openfoam_case.T = T.T() 

636 openfoam_case.T.values['boundaryField'] = {} 

637 openfoam_case.T.values['internalField'] \ 

638 = (f'uniform ' 

639 f'{of_utils.float_cutoff(openfoam_case.current_zone.air_temp)}') 

640 

641 for bound in stl_bounds: 

642 openfoam_case.T.values['boundaryField'].update( 

643 {bound.solid_name: bound.T}) 

644 for heater in heaters: 

645 # openfoam_case.T.values['boundaryField'].update( 

646 # {heater.porous_media.solid_name: 

647 # heater.porous_media.T}) 

648 openfoam_case.T.values['boundaryField'].update( 

649 {heater.heater_surface.solid_name: 

650 heater.heater_surface.T}) 

651 for air_terminal in air_terminals: 

652 if air_terminal.diffuser.solid_name: 

653 openfoam_case.T.values['boundaryField'].update( 

654 {air_terminal.diffuser.solid_name: air_terminal.diffuser.T}) 

655 if air_terminal.source_sink.solid_name: 

656 openfoam_case.T.values['boundaryField'].update({ 

657 air_terminal.source_sink.solid_name: 

658 air_terminal.source_sink.T}) 

659 if air_terminal.box.solid_name: 

660 openfoam_case.T.values['boundaryField'].update({ 

661 air_terminal.box.solid_name: air_terminal.box.T 

662 }) 

663 for furn in furniture: 

664 openfoam_case.T.values['boundaryField'].update( 

665 {furn.solid_name: furn.T}) 

666 for person in people: 

667 for body_part in person.body_parts_dict.values(): 

668 openfoam_case.T.values['boundaryField'].update( 

669 {body_part.solid_name: body_part.T}) 

670 default_name_list = openfoam_case.default_surface_names 

671 for name in default_name_list: 

672 openfoam_case.T.values['boundaryField'].update( 

673 {name: OpenFOAMBaseBoundaryFields().T}) 

674 openfoam_case.T.save(openfoam_case.openfoam_dir) 

675 

676 @staticmethod 

677 def create_U(openfoam_case, openfoam_elements):