Coverage for bim2sim/elements/hvac_elements.py: 67%

1"""Module contains the different classes for all HVAC elements""" 

2import inspect 

3import itertools 

4import logging 

5import math 

6import re 

7import sys 

8from typing import Set, List, Tuple, Generator, Union, Type 

9 

10import numpy as np 

11 

12from bim2sim.kernel.decision import ListDecision, DecisionBunch 

13from bim2sim.elements.mapping import condition, attribute 

14from bim2sim.elements.base_elements import Port, ProductBased, IFCBased 

15from bim2sim.elements.mapping.ifc2python import get_ports as ifc2py_get_ports 

16from bim2sim.elements.mapping.ifc2python import get_predefined_type 

17from bim2sim.elements.mapping.units import ureg 

18 

19logger = logging.getLogger(__name__) 

20quality_logger = logging.getLogger('bim2sim.QualityReport') 

21 

22 

23def diameter_post_processing(value): 

24 if isinstance(value, (list, set)): 

25 return sum(value) / len(value) 

26 return value 

27 

28 

29def length_post_processing(value): 

30 if isinstance(value, (list, set)): 

31 return max(value) 

32 return value 

33 

34 

35class HVACPort(Port): 

36 """Port of HVACProduct.""" 

37 vl_pattern = re.compile('.*vorlauf.*', 

38 re.IGNORECASE) # TODO: extend pattern 

39 rl_pattern = re.compile('.*rücklauf.*', re.IGNORECASE) 

40 

41 def __init__( 

42 self, *args, groups: Set = None, 

43 flow_direction: int = 0, **kwargs): 

44 super().__init__(*args, **kwargs) 

45 

46 self._flow_master = False 

47 self._flow_direction = None 

48 self._flow_side = None 

49 self.groups = groups or set() 

50 self.flow_direction = flow_direction 

51 

52 @classmethod 

53 def ifc2args(cls, ifc) -> Tuple[tuple, dict]: 

54 args, kwargs = super().ifc2args(ifc) 

55 groups = {assg.RelatingGroup.ObjectType 

56 for assg in ifc.HasAssignments} 

57 flow_direction = None 

58 if ifc.FlowDirection == 'SOURCE': 

59 flow_direction = 1 

60 elif ifc.FlowDirection == 'SINK': 

61 flow_direction = -1 

62 elif ifc.FlowDirection in ['SINKANDSOURCE', 'SOURCEANDSINK']: 

63 flow_direction = 0 

64 

65 kwargs['groups'] = groups 

66 kwargs['flow_direction'] = flow_direction 

67 return args, kwargs 

68 

69 def _calc_position(self, name) -> np.array: 

70 """returns absolute position as np.array""" 

71 try: 

72 relative_placement = \ 

73 self.parent.ifc.ObjectPlacement.RelativePlacement 

74 x_direction = np.array( 

75 relative_placement.RefDirection.DirectionRatios) 

76 z_direction = np.array(relative_placement.Axis.DirectionRatios) 

77 except AttributeError: 

78 x_direction = np.array([1, 0, 0]) 

79 z_direction = np.array([0, 0, 1]) 

80 y_direction = np.cross(z_direction, x_direction) 

81 directions = np.array((x_direction, y_direction, z_direction)).T 

82 port_coordinates_relative = \ 

83 np.array( 

84 self.ifc.ObjectPlacement.RelativePlacement.Location.Coordinates) 

85 coordinates = self.parent.position + np.matmul(directions, 

86 port_coordinates_relative) 

87 

88 if all(coordinates == np.array([0, 0, 0])): 

89 quality_logger.info("Suspect position [0, 0, 0] for %s", self) 

90 return coordinates 

91 

92 @classmethod 

93 def pre_validate(cls, ifc) -> bool: 

94 return True 

95 

96 def validate_creation(self) -> bool: 

97 return True 

98 

99 @property 

100 def flow_master(self): 

101 """Lock flow direction for port""" 

102 return self._flow_master 

103 

104 @flow_master.setter 

105 def flow_master(self, value: bool): 

106 self._flow_master = value 

107 

108 @property 

109 def flow_direction(self): 

110 """Flow direction of port 

111 

112 -1 = medium flows into port 

113 1 = medium flows out of port 

114 0 = medium flow undirected 

115 None = flow direction unknown""" 

116 return self._flow_direction 

117 

118 @flow_direction.setter 

119 def flow_direction(self, value): 

120 if self._flow_master: 

121 raise AttributeError("Can't set flow direction for flow master.") 

122 if value not in (-1, 0, 1, None): 

123 raise AttributeError("Invalid value. Use one of (-1, 0, 1, None).") 

124 self._flow_direction = value 

125 

126 @property 

127 def verbose_flow_direction(self): 

128 """Flow direction of port""" 

129 if self.flow_direction == -1: 

130 return 'SINK' 

131 if self.flow_direction == 0: 

132 return 'SINKANDSOURCE' 

133 if self.flow_direction == 1: 

134 return 'SOURCE' 

135 return 'UNKNOWN' 

136 

137 @property 

138 def flow_side(self): 

139 """ 

140 Flow side of port. 

141 

142 1 = supply flow (Vorlauf) 

143 -1 = return flow (Rücklauf) 

144 0 = unknown 

145 """ 

146 if self._flow_side is None: 

147 self._flow_side = self.determine_flow_side() 

148 return self._flow_side 

149 

150 @flow_side.setter 

151 def flow_side(self, value): 

152 if value not in (-1, 0, 1): 

153 raise ValueError("allowed values for flow_side are 1, 0, -1") 

154 previous = self._flow_side 

155 self._flow_side = value 

156 if previous: 

157 if previous != value: 

158 logger.info("Overwriting flow_side for %r with %s" % ( 

159 self, self.verbose_flow_side)) 

160 else: 

161 logger.debug( 

162 "Set flow_side for %r to %s" % (self, self.verbose_flow_side)) 

163 

164 @property 

165 def verbose_flow_side(self): 

166 if self.flow_side == 1: 

167 return "VL" 

168 if self.flow_side == -1: 

169 return "RL" 

170 return "UNKNOWN" 

171 

172 def determine_flow_side(self): 

173 """Check groups for hints of flow_side and returns flow_side if hints are definitely""" 

174 vl = None 

175 rl = None 

176 if self.parent.is_generator(): 

177 if self.flow_direction == 1: 

178 vl = True 

179 elif self.flow_direction == -1: 

180 rl = True 

181 elif self.parent.is_consumer(): 

182 if self.flow_direction == 1: 

183 rl = True 

184 elif self.flow_direction == -1: 

185 vl = True 

186 if not vl: 

187 vl = any(filter(self.vl_pattern.match, self.groups)) 

188 if not rl: 

189 rl = any(filter(self.rl_pattern.match, self.groups)) 

190 

191 if vl and not rl: 

192 return 1 

193 if rl and not vl: 

194 return -1 

195 return 0 

196 

197 

198class HVACProduct(ProductBased): 

199 domain = 'HVAC' 

200 

201 def __init__(self, *args, **kwargs): 

202 super().__init__(*args, **kwargs) 

203 self.inner_connections: List[Tuple[HVACPort, HVACPort]] \ 

204 = self.get_inner_connections() 

205 

206 @property 

207 def expected_hvac_ports(self): 

208 raise NotImplementedError(f"Please define the expected number of ports " 

209 f"for the class {self.__class__.__name__} ") 

210 

211 def get_ports(self) -> list: 

212 """Returns a list of ports of this product.""" 

213 ports = ifc2py_get_ports(self.ifc) 

214 hvac_ports = [] 

215 for port in ports: 

216 port_valid = True 

217 if port.is_a() != 'IfcDistributionPort': 

218 port_valid = False 

219 else: 

220 predefined_type = get_predefined_type(port) 

221 if predefined_type in [ 

222 'CABLE', 'CABLECARRIER', 'WIRELESS']: 

223 port_valid = False 

224 if port_valid: 

225 hvac_ports.append(HVACPort.from_ifc( 

226 ifc=port, parent=self)) 

227 else: 

228 logger.warning( 

229 "Not included %s as Port in %s with GUID %s", 

230 port.is_a(), 

231 self.__class__.__name__, 

232 self.guid) 

233 return hvac_ports 

234 

235 def get_inner_connections(self) -> List[Tuple[HVACPort, HVACPort]]: 

236 """Returns inner connections of Element. 

237 

238 By default each port is connected to each other port. 

239 Overwrite for other connections.""" 

240 

241 connections = [] 

242 for port0, port1 in itertools.combinations(self.ports, 2): 

243 connections.append((port0, port1)) 

244 return connections 

245 

246 def decide_inner_connections(self) -> Generator[DecisionBunch, None, None]: 

247 """Generator method yielding decisions to set inner connections.""" 

248 

249 if len(self.ports) < 2: 

250 # not possible to connect anything 

251 return 

252 

253 # TODO: extend pattern 

254 vl_pattern = re.compile('.*vorlauf.*', re.IGNORECASE) 

255 rl_pattern = re.compile('.*rücklauf.*', re.IGNORECASE) 

256 

257 # use score for ports to help user find best match_graph 

258 score_vl = {} 

259 score_rl = {} 

260 for port in self.ports: 

261 bonus_vl = 0 

262 bonus_rl = 0 

263 # connected to pipe 

264 if port.connection and type(port.connection.parent) \ 

265 in [Pipe, PipeFitting]: 

266 bonus_vl += 1 

267 bonus_rl += 1 

268 # string hints 

269 if any(filter(vl_pattern.match, port.groups)): 

270 bonus_vl += 1 

271 if any(filter(rl_pattern.match, port.groups)): 

272 bonus_rl += 1 

273 # flow direction 

274 if port.flow_direction == 1: 

275 bonus_vl += .5 

276 if port.flow_direction == -1: 

277 bonus_rl += .5 

278 score_vl[port] = bonus_vl 

279 score_rl[port] = bonus_rl 

280 

281 # created sorted choices 

282 choices_vl = [port.guid for port, score in 

283 sorted(score_vl.items(), key=lambda item: item[1], 

284 reverse=True)] 

285 choices_rl = [port.guid for port, score in 

286 sorted(score_rl.items(), key=lambda item: item[1], 

287 reverse=True)] 

288 decision_vl = ListDecision(f"Please select VL Port for {self}.", 

289 choices=choices_vl, 

290 default=choices_vl[0], # best guess 

291 key='VL', 

292 global_key='VL_port_of_' + self.guid) 

293 decision_rl = ListDecision(f"Please select RL Port for {self}.", 

294 choices=choices_rl, 

295 default=choices_rl[0], # best guess 

296 key='RL', 

297 global_key='RL_port_of_' + self.guid) 

298 decisions = DecisionBunch((decision_vl, decision_rl)) 

299 yield decisions 

300 

301 port_dict = {port.guid: port for port in self.ports} 

302 vl = port_dict[decision_vl.value] 

303 rl = port_dict[decision_rl.value] 

304 # set flow correct side 

305 vl.flow_side = 1 

306 rl.flow_side = -1 

307 self.inner_connections.append((vl, rl)) 

308 

309 def validate_ports(self): 

310 if isinstance(self.expected_hvac_ports, tuple): 

311 if self.expected_hvac_ports[0] <= len(self.ports) \ 

312 <= self.expected_hvac_ports[-1]: 

313 return True 

314 else: 

315 if len(self.ports) == self.expected_hvac_ports: 

316 return True 

317 return False 

318 

319 def is_generator(self): 

320 return False 

321 

322 def is_consumer(self): 

323 return False 

324 

325 def calc_cost_group(self) -> [int]: 

326 """Default cost group for HVAC elements is 400""" 

327 return 400 

328 

329 def __repr__(self): 

330 return "<%s (guid: %s, ports: %d)>" % ( 

331 self.__class__.__name__, self.guid, len(self.ports)) 

332 

333 

334class HeatPump(HVACProduct): 

335 """"HeatPump""" 

336 

337 ifc_types = { 

338 'IfcUnitaryEquipment': ['*'] 

339 } 

340 # IFC Schema does not support Heatpumps directly, but default of unitary 

341 # equipment is set to HeatPump now and expected ports to 4 to try to 

342 # identify heat pumps 

343 

344 pattern_ifc_type = [ 

345 re.compile('Heat.?pump', flags=re.IGNORECASE), 

346 re.compile('W(ä|ae)rme.?pumpe', flags=re.IGNORECASE), 

347 ] 

348 

349 min_power = attribute.Attribute( 

350 description='Minimum power that heat pump operates at.', 

351 unit=ureg.kilowatt, 

352 ) 

353 rated_power = attribute.Attribute( 

354 description='Rated power of heat pump.', 

355 unit=ureg.kilowatt, 

356 ) 

357 efficiency = attribute.Attribute( 

358 description='Efficiency of heat pump provided as list with pairs of ' 

359 '[percentage_of_rated_power,efficiency]', 

360 unit=ureg.dimensionless 

361 ) 

362 vdi_performance_data_table=attribute.Attribute( 

363 description="temp dummy to test vdi table export", 

364 ) 

365 is_reversible = attribute.Attribute( 

366 description="Does the heat pump support cooling as well?", 

367 unit=ureg.dimensionless 

368 ) 

369 rated_cooling_power = attribute.Attribute( 

370 description='Rated power of heat pump in cooling mode.', 

371 unit=ureg.kilowatt, 

372 ) 

373 COP = attribute.Attribute( 

374 description="The COP of the heat pump, definition based on VDI 3805-22", 

375 unit=ureg.dimensionless 

376 ) 

377 internal_pump = attribute.Attribute( 

378 description="The COP of the heat pump, definition based on VDI 3805-22", 

379 ) 

380 

381 @property 

382 def expected_hvac_ports(self): 

383 return 4 

384 

385 

386class Chiller(HVACProduct): 

387 """"Chiller""" 

388 

389 ifc_types = { 

390 'IfcChiller': ['*', 'AIRCOOLED', 'WATERCOOLED', 'HEATRECOVERY']} 

391 

392 pattern_ifc_type = [ 

393 re.compile('Chiller', flags=re.IGNORECASE), 

394 re.compile('K(ä|ae)lte.?maschine', flags=re.IGNORECASE), 

395 ] 

396 

397 rated_power = attribute.Attribute( 

398 description='Rated power of Chiller.', 

399 default_ps=('Pset_ChillerTypeCommon', 'NominalCapacity'), 

400 unit=ureg.kilowatt, 

401 ) 

402 

403 nominal_power_consumption = attribute.Attribute( 

404 description="nominal power consumption of chiller", 

405 default_ps=('Pset_ChillerTypeCommon', 'NominalPowerConsumption'), 

406 unit=ureg.kilowatt, 

407 ) 

408 

409 nominal_COP = attribute.Attribute( 

410 description="Chiller efficiency at nominal load", 

411 default_ps=('Pset_ChillerTypeCommon', 'NominalEfficiency'), 

412 ) 

413 

414 capacity_curve = attribute.Attribute( 

415 # (Capacity[W], CondensingTemperature[K], EvaporatingTemperature[K]) 

416 description="Chiller's thermal power as function of fluid temperature", 

417 default_ps=('Pset_ChillerTypeCommon', 'CapacityCurve'), 

418 ) 

419 

420 COP = attribute.Attribute( 

421 # (COP, CondensingTemperature[K], EvaporatingTemperature[K]) 

422 description="Chiller's COP as function of fluid temperature", 

423 default_ps=('Pset_ChillerTypeCommon', 'CoefficientOfPerformanceCurve'), 

424 ) 

425 

426 full_load_ratio = attribute.Attribute( 

427 # (FracFullLoadPower, PartLoadRatio) 

428 description="Chiller's thermal partial load power as function of fluid " 

429 "temperature", 

430 default_ps=('Pset_ChillerTypeCommon', 'FullLoadRatioCurve'), 

431 ) 

432 

433 nominal_condensing_temperature = attribute.Attribute( 

434 description='Nominal condenser temperature', 

435 default_ps=('Pset_ChillerTypeCommon', 'NominalCondensingTemperature'), 

436 unit=ureg.celsius, 

437 ) 

438 

439 nominal_evaporating_temperature = attribute.Attribute( 

440 description='Nominal condenser temperature', 

441 default_ps=('Pset_ChillerTypeCommon', 'NominalEvaporatingTemperature'), 

442 unit=ureg.celsius, 

443 ) 

444 

445 min_power = attribute.Attribute( 

446 description='Minimum power at which Chiller operates at.', 

447 unit=ureg.kilowatt, 

448 ) 

449 

450 @property 

451 def expected_hvac_ports(self): 

452 return 4 

453 

454 

455class CoolingTower(HVACProduct): 

456 """"CoolingTower""" 

457 

458 ifc_types = { 

459 'IfcCoolingTower': 

460 ['*', 'NATURALDRAFT', 'MECHANICALINDUCEDDRAFT', 

461 'MECHANICALFORCEDDRAFT'] 

462 } 

463 

464 pattern_ifc_type = [ 

465 re.compile('Cooling.?Tower', flags=re.IGNORECASE), 

466 re.compile('Recooling.?Plant', flags=re.IGNORECASE), 

467 re.compile('K(ü|ue)hl.?turm', flags=re.IGNORECASE), 

468 re.compile('R(ü|ue)ck.?K(ü|ue)hl.?(werk|turm|er)', flags=re.IGNORECASE), 

469 re.compile('RKA', flags=re.IGNORECASE), 

470 ] 

471 

472 min_power = attribute.Attribute( 

473 description='Minimum power that CoolingTower operates at.', 

474 unit=ureg.kilowatt, 

475 ) 

476 rated_power = attribute.Attribute( 

477 description='Rated power of CoolingTower.', 

478 default_ps=('Pset_CoolingTowerTypeCommon', 'NominalCapacity'), 

479 unit=ureg.kilowatt, 

480 ) 

481 efficiency = attribute.Attribute( 

482 description='Efficiency of CoolingTower provided as list with pairs of ' 

483 '[percentage_of_rated_power,efficiency]', 

484 unit=ureg.dimensionless, 

485 ) 

486 

487 @property 

488 def expected_hvac_ports(self): 

489 return 2 

490 

491 

492class HeatExchanger(HVACProduct): 

493 """"Heat exchanger""" 

494 

495 ifc_types = {'IfcHeatExchanger': ['*', 'PLATE', 'SHELLANDTUBE']} 

496 

497 pattern_ifc_type = [ 

498 re.compile('Heat.?Exchanger', flags=re.IGNORECASE), 

499 re.compile('W(ä|ae)rme.?(ü|e)bertrager', flags=re.IGNORECASE), 

500 re.compile('W(ä|ae)rme.?tauscher', flags=re.IGNORECASE), 

501 ] 

502 

503 min_power = attribute.Attribute( 

504 description='Minimum power that HeatExchange operates at.', 

505 unit=ureg.kilowatt, 

506 ) 

507 rated_power = attribute.Attribute( 

508 description='Rated power of HeatExchange.', 

509 unit=ureg.kilowatt, 

510 ) 

511 efficiency = attribute.Attribute( 

512 description='Efficiency of HeatExchange provided as list with pairs of ' 

513 '[percentage_of_rated_power,efficiency]', 

514 unit=ureg.dimensionless, 

515 ) 

516 

517 @property 

518 def expected_hvac_ports(self): 

519 return 4 

520 

521 

522class Boiler(HVACProduct): 

523 """Boiler""" 

524 ifc_types = {'IfcBoiler': ['*', 'WATER', 'STEAM']} 

525 

526 pattern_ifc_type = [ 

527 # re.compile('Heat.?pump', flags=re.IGNORECASE), 

528 re.compile('Kessel', flags=re.IGNORECASE), 

529 re.compile('Boiler', flags=re.IGNORECASE), 

530 ] 

531 

532 @property 

533 def expected_hvac_ports(self): 

534 return 2 

535 

536 def is_generator(self): 

537 """Boiler is a generator function.""" 

538 return True 

539 

540 def get_inner_connections(self): 

541 # TODO see #167 

542 if len(self.ports) > 2: 

543 return [] 

544 else: 

545 connections = super().get_inner_connections() 

546 return connections 

547 

548 water_volume = attribute.Attribute( 

549 description="Water volume of boiler", 

550 default_ps=('Pset_BoilerTypeCommon', 'WaterStorageCapacity'), 

551 unit=ureg.meter ** 3, 

552 ) 

553 

554 dry_mass = attribute.Attribute( 

555 description="Weight of the element, not including contained fluid.", 

556 default_ps=('Qto_BoilerBaseQuantities', 'GrossWeight'), 

557 unit=ureg.kg, 

558 ) 

559 

560 nominal_power_consumption = attribute.Attribute( 

561 description="nominal energy consumption of boiler", 

562 default_ps=('Pset_BoilerTypeCommon', 'NominalEnergyConsumption'), 

563 unit=ureg.kilowatt, 

564 ) 

565 

566 efficiency = attribute.Attribute( 

567 # (Efficiency, PartialLoadFactor) 

568 description="Efficiency of boiler provided as list with pairs of " 

569 "percentage_of_rated_power and efficiency", 

570 default_ps=('Pset_BoilerTypeCommon', 'PartialLoadEfficiencyCurves'), 

571 unit=ureg.dimensionless, 

572 ) 

573 

574 energy_source = attribute.Attribute( 

575 description="Final energy source of boiler", 

576 default_ps=('Pset_BoilerTypeCommon', 'EnergySource'), 

577 ) 

578 

579 operating_mode = attribute.Attribute( 

580 # [fixed, twostep, modulating, other, unknown, unset] 

581 description="Boiler's operating mode", 

582 default_ps=('Pset_BoilerTypeCommon', 'OperatingMode'), 

583 unit=ureg.dimensionless, 

584 ) 

585 

586 part_load_ratio_range = attribute.Attribute( 

587 description="Allowable part load ratio range (Bounded value).", 

588 default_ps=('Pset_BoilerTypeCommon', 'NominalPartLoadRatio'), 

589 ) 

590 

591 def _get_minimal_part_load_ratio(self, name): 

592 """Calculates the minimal part load ratio based on the given range.""" 

593 # TODO this is not tested yet but should work with the new BoundedValue 

594 # in ifc2python 

595 if hasattr(self, "part_load_ratio_range"): 

596 return min(self.part_load_ratio_range) 

597 

598 def _normalise_value_zero_to_one(self, value): 

599 if (max(self.part_load_ratio_range) == 100 

600 and min(self.part_load_ratio_range) == 0): 

601 return value * 0.01 

602 

603 minimal_part_load_ratio = attribute.Attribute( 

604 description="Minimal part load ratio", 

605 functions=[_get_minimal_part_load_ratio], 

606 # TODO use ifc_post_processing to make sure that ranged value are between 

607 # 0 and 1 

608 ifc_postprocessing=[_normalise_value_zero_to_one] 

609 ) 

610 

611 

612 def _calc_nominal_efficiency(self, name): 

613 """function to calculate the boiler nominal efficiency using the 

614 efficiency curve""" 

615 

616 if isinstance(self.efficiency, list): 

617 efficiency_curve = {y: x for x, y in self.efficiency} 

618 nominal_eff = efficiency_curve.get(1, None) 

619 if nominal_eff: 

620 return nominal_eff 

621 else: 

622 # ToDo: linear regression 

623 raise NotImplementedError 

624 else: 

625 # WORKAROUND: input of lists is not yet implemented 

626 return self.efficiency 

627 

628 nominal_efficiency = attribute.Attribute( 

629 description="""Boiler efficiency at nominal load""", 

630 functions=[_calc_nominal_efficiency], 

631 unit=ureg.dimensionless, 

632 ) 

633 

634 def _calc_rated_power(self, name) -> ureg.Quantity: 

635 """Function to calculate the rated power of the boiler using the nominal 

636 efficiency and the nominal power consumption""" 

637 return self.nominal_efficiency * self.nominal_power_consumption 

638 

639 rated_power = attribute.Attribute( 

640 description="Rated power of boiler", 

641 unit=ureg.kilowatt, 

642 functions=[_calc_rated_power], 

643 ) 

644 

645 def _calc_partial_load_efficiency(self, name): 

646 """Function to calculate the boiler efficiency at partial load using the 

647 nominal partial ratio and the efficiency curve""" 

648 if isinstance(self.efficiency, list): 

649 efficiency_curve = {y: x for x, y in self.efficiency} 

650 partial_eff = efficiency_curve.get(max(self.part_load_ratio_range), 

651 None) 

652 if partial_eff: 

653 return partial_eff 

654 else: 

655 # ToDo: linear regression 

656 raise NotImplementedError 

657 else: 

658 # WORKAROUND: input of lists is not yet implemented 

659 return self.efficiency 

660 

661 partial_load_efficiency = attribute.Attribute( 

662 description="Boiler efficiency at partial load", 

663 functions=[_calc_partial_load_efficiency], 

664 unit=ureg.dimensionless, 

665 default=0.15 

666 ) 

667 

668 def _calc_min_power(self, name) -> ureg.Quantity: 

669 """Function to calculate the minimum power that boiler operates at, 

670 using the partial load efficiency and the nominal power consumption""" 

671 return self.partial_load_efficiency * self.nominal_power_consumption 

672 

673 min_power = attribute.Attribute( 

674 description="Minimum power that boiler operates at", 

675 unit=ureg.kilowatt, 

676 functions=[_calc_min_power], 

677 ) 

678 

679 def _calc_min_PLR(self, name) -> ureg.Quantity: 

680 """Function to calculate the minimal PLR of the boiler using the minimal 

681 power and the rated power""" 

682 return self.min_power / self.rated_power 

683 

684 min_PLR = attribute.Attribute( 

685 description="Minimum Part load ratio", 

686 unit=ureg.dimensionless, 

687 functions=[_calc_min_PLR], 

688 ) 

689 flow_temperature = attribute.Attribute( 

690 description="Nominal inlet temperature", 

691 default_ps=('Pset_BoilerTypeCommon', 'WaterInletTemperatureRange'), 

692 unit=ureg.celsius, 

693 ) 

694 return_temperature = attribute.Attribute( 

695 description="Nominal outlet temperature", 

696 default_ps=('Pset_BoilerTypeCommon', 'OutletTemperatureRange'), 

697 unit=ureg.celsius, 

698 ) 

699 

700 def _calc_dT_water(self, name) -> ureg.Quantity: 

701 """Function to calculate the delta temperature of the boiler using the 

702 return and flow temperature""" 

703 return self.return_temperature - self.flow_temperature 

704 

705 dT_water = attribute.Attribute( 

706 description="Nominal temperature difference", 

707 unit=ureg.kelvin, 

708 functions=[_calc_dT_water], 

709 ) 

710 

711 

712class Pipe(HVACProduct): 

713 ifc_types = { 

714 "IfcPipeSegment": 

715 ['*', 'CULVERT', 'FLEXIBLESEGMENT', 'RIGIDSEGMENT', 'GUTTER', 

716 'SPOOL'] 

717 } 

718 

719 @property 

720 def expected_hvac_ports(self): 

721 return 2 

722 

723 conditions = [ 

724 condition.RangeCondition("diameter", 5.0 * ureg.millimeter, 

725 300.00 * ureg.millimeter) # ToDo: unit?! 

726 ] 

727 

728 def _calc_diameter_from_radius(self, name) -> ureg.Quantity: 

729 if self.radius: 

730 return self.radius*2 

731 else: 

732 return None 

733 

734 diameter = attribute.Attribute( 

735 default_ps=('Pset_PipeSegmentTypeCommon', 'NominalDiameter'), 

736 unit=ureg.millimeter, 

737 patterns=[ 

738 re.compile('.*Durchmesser.*', flags=re.IGNORECASE), 

739 re.compile('.*Diameter.*', flags=re.IGNORECASE), 

740 ], 

741 functions=[_calc_diameter_from_radius], 

742 ifc_postprocessing=diameter_post_processing, 

743 ) 

744 # TODO #432 implement function to get diamter from shape 

745 

746 radius = attribute.Attribute( 

747 patterns=[ 

748 re.compile('.*Radius.*', flags=re.IGNORECASE) 

749 ], 

750 unit=ureg.millimeter 

751 ) 

752 

753 outer_diameter = attribute.Attribute( 

754 description="Outer diameter of pipe", 

755 default_ps=('Pset_PipeSegmentTypeCommon', 'OuterDiameter'), 

756 unit=ureg.millimeter, 

757 ) 

758 

759 inner_diameter = attribute.Attribute( 

760 description="Inner diameter of pipe", 

761 default_ps=('Pset_PipeSegmentTypeCommon', 'InnerDiameter'), 

762 unit=ureg.millimeter, 

763 ) 

764 

765 def _length_from_geometry(self, name): 

766 """ 

767 Function to calculate the length of the pipe from the geometry 

768 """ 

769 try: 

770 return Pipe.get_lenght_from_shape(self.ifc.Representation) \ 

771 * ureg.meter 

772 except AttributeError: 

773 return None 

774 

775 length = attribute.Attribute( 

776 default_ps=('Qto_PipeSegmentBaseQuantities', 'Length'), 

777 unit=ureg.meter, 

778 patterns=[ 

779 re.compile('.*Länge.*', flags=re.IGNORECASE), 

780 re.compile('.*Length.*', flags=re.IGNORECASE), 

781 ], 

782 ifc_postprocessing=length_post_processing, 

783 functions=[_length_from_geometry], 

784 ) 

785 

786 roughness_coefficient = attribute.Attribute( 

787 description="Interior roughness coefficient of pipe", 

788 default_ps=('Pset_PipeSegmentOccurrence', 

789 'InteriorRoughnessCoefficient'), 

790 unit=ureg.millimeter, 

791 ) 

792 

793 @staticmethod 

794 def get_lenght_from_shape(ifc_representation): 

795 """Search for extruded depth in representations 

796 

797 Warning: Found extrusion may net be the required length! 

798 :raises: AttributeError if not exactly one extrusion is found""" 

799 candidates = [] 

800 try: 

801 for representation in ifc_representation.Representations: 

802 for item in representation.Items: 

803 if item.is_a() == 'IfcExtrudedAreaSolid': 

804 candidates.append(item.Depth) 

805 except: 

806 raise AttributeError("Failed to determine length.") 

807 if not candidates: 

808 raise AttributeError("No representation to determine length.") 

809 if len(candidates) > 1: 

810 raise AttributeError( 

811 "Too many representations to dertermine length %s." % candidates) 

812 

813 return candidates[0] 

814 

815 

816class PipeFitting(HVACProduct): 

817 ifc_types = { 

818 "IfcPipeFitting": 

819 ['*', 'BEND', 'CONNECTOR', 'ENTRY', 'EXIT', 'JUNCTION', 

820 'OBSTRUCTION', 'TRANSITION'] 

821 } 

822 pattern_ifc_type = [ 

823 re.compile('Bogen', flags=re.IGNORECASE), 

824 re.compile('Bend', flags=re.IGNORECASE), 

825 ] 

826 

827 @property 

828 def expected_hvac_ports(self): 

829 return (2, 3) 

830 

831 conditions = [ 

832 condition.RangeCondition("diameter", 5.0 * ureg.millimeter, 

833 300.00 * ureg.millimeter) 

834 ] 

835 

836 diameter = attribute.Attribute( 

837 default_ps=('Pset_PipeFittingTypeCommon', 'NominalDiameter'), 

838 unit=ureg.millimeter, 

839 patterns=[ 

840 re.compile('.*Durchmesser.*', flags=re.IGNORECASE), 

841 re.compile('.*Diameter.*', flags=re.IGNORECASE), 

842 ], 

843 ifc_postprocessing=diameter_post_processing, 

844 ) 

845 # TODO #432 implement function to get diamter from shape 

846 

847 length = attribute.Attribute( 

848 default_ps=("Qto_PipeFittingBaseQuantities", "Length"),