Coverage for backend/ahuora-builder/src/ahuora_builder/methods/adapter_library.py: 100%

1from idaes.models.unit_models import ( 

2 Pump, 

3 Heater, 

4 Mixer, 

5 StateJunction, 

6 HeatExchanger, 

7 Turbine, 

8 PressureChanger, 

9) 

10from idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback 

11from idaes.models.unit_models.pressure_changer import ThermodynamicAssumption 

12from idaes.models.unit_models.separator import SplittingType, EnergySplittingType 

13from ahuora_builder.custom.heat_exchanger_1d_wrapper import HeatExchanger1DWrapper 

14from . import adapter_methods as methods 

15from ..custom.custom_heat_exchanger import CustomHeatExchanger 

16from ..custom.PySMOModel import PySMOModel 

17from ..custom.energy.link import Link 

18from ..custom.energy.power_property_package import PowerParameterBlock 

19from ..custom.energy.ac_property_package import acParameterBlock 

20from ..custom.energy.transformer_property_package import transformerParameterBlock 

21from ..custom.updated_pressure_changer import Compressor 

22from ..custom.energy.solar import Solar 

23from ..custom.custom_valve import Valve 

24from ..custom.energy.wind import Wind 

25from ..custom.energy.energy_mixer import EnergyMixer 

26from ..custom.energy.bus import Bus 

27from ..custom.energy.acBus import acBus 

28from ..custom.energy.transmissionLine import transmissionLine 

29from ..custom.valve_wrapper import ValveWrapper 

30from ..custom.energy.load import Load 

31from ..custom.energy.hydro import Hydro 

32from ..custom.energy.transformer import Transformer 

33from ..custom.energy.storage import Storage 

34from ..custom.direct_steam_injection import Dsi 

35from ..custom.translator import GenericTranslator 

36from idaes.models.control.controller import ControllerType, ControllerMVBoundType 

37from ..custom.PIDController import PIDController2 

38from ..custom.energy.grid import Grid 

39from ..custom.custom_heater import DynamicHeater 

40from ..custom.custom_tank import CustomTank 

41from ..custom.custom_compressor import CustomCompressor 

42from ..custom.custom_pump import CustomPump 

43from ..custom.integration_block import IntegrationBlock 

44from idaes.models.unit_models.cstr import CSTR 

45from ..custom.energy.energy_splitter import EnergySplitter 

46from ..custom.custom_turbine import CustomTurbine 

47from ..custom.energy.mainDistributionBoard import MDB 

48from ..custom.custom_separator import CustomSeparator 

49from ..custom.custom_variable import CustomVariable 

50from ..custom.thermal_utility_systems.steam_header import SteamHeader 

51from ..custom.thermal_utility_systems.header import simple_header 

52from ..custom.reactions.hda_stoich import HDAStoichiometricReactor 

53from ..custom.custom_heat_exchanger_1d import CustomHeatExchanger1D 

54from ..custom.thermal_utility_systems.simple_heat_pump import SimpleHeatPump 

55from ..custom.thermal_utility_systems.steam_user import SteamUser 

56from ..custom.thermal_utility_systems.desuperheater import Desuperheater 

57from idaes.models_extra.power_generation.unit_models.waterpipe import WaterPipe 

58from ..custom.SimpleEffectivenessHX_DH import HeatExchangerEffectiveness 

59from idaes.models.unit_models.heat_exchanger_lc import HeatExchangerLumpedCapacitance 

60from idaes.models_extra.column_models.plate_heat_exchanger import PlateHeatExchanger 

61from ..custom.custom_cooler import CustomCooler 

62from ..custom.watertap.reverse_osmosis_0d import ReverseOsmosis0D 

63from ..custom.watertap.pressure_exchanger import PressureExchanger 

64 

65class UnitModelConstructor: 

66 """ 

67 Schema for adapter library items 

68 """ 

69 

70 def __init__(self, model_constructor: type, arg_parsers: dict): 

71 # idaes model constructor 

72 self.model_constructor: type = model_constructor 

73 # dictionary of argument parsers 

74 self.arg_parsers: dict[str,methods.AdapterBase] = arg_parsers 

75 

76 

77 

78""" 

79A dictionary of adapters for the idaes model constructors 

80""" 

81AdapterLibrary: dict[str, UnitModelConstructor] = { 

82 "pump": UnitModelConstructor( 

83 CustomPump, 

84 { 

85 "property_package": methods.PropertyPackage(), 

86 "dynamic": methods.Constant(False), 

87 "power_property_package": methods.PowerPropertyPackage(), 

88 

89 }, 

90 ), 

91 "heater": UnitModelConstructor( 

92 DynamicHeater, 

93 { 

94 "property_package": methods.PropertyPackage(), 

95 "has_pressure_change": methods.Value(), 

96 "dynamic": methods.Value(), 

97 "has_holdup": methods.Value(), 

98 }, 

99 ), 

100 "compressor": UnitModelConstructor( 

101 CustomCompressor, 

102 { 

103 "property_package": methods.PropertyPackage(), 

104 "power_property_package": methods.PowerPropertyPackage(), 

105 "dynamic": methods.Constant(False), 

106 }, 

107 ), 

108 "turbine": UnitModelConstructor( 

109 CustomTurbine, 

110 { 

111 "property_package": methods.PropertyPackage(), 

112 "power_property_package": methods.PowerPropertyPackage(), 

113 "dynamic": methods.Constant(False), 

114 "calculation_method": methods.Constant("isentropic"), 

115 }, 

116 ), 

117 "willans_turbine": UnitModelConstructor( 

118 CustomTurbine, 

119 { 

120 "property_package": methods.PropertyPackage(), 

121 "power_property_package": methods.PowerPropertyPackage(), 

122 "dynamic": methods.Constant(False), 

123 "calculation_method": methods.Constant("simple_willans"), 

124 }, 

125 ), 

126 "pl_turbine": UnitModelConstructor( 

127 CustomTurbine, 

128 { 

129 "property_package": methods.PropertyPackage(), 

130 "power_property_package": methods.PowerPropertyPackage(), 

131 "dynamic": methods.Constant(False), 

132 "calculation_method": methods.Constant("part_load_willans"), 

133 } 

134 ), 

135 "dts_turbine": UnitModelConstructor( 

136 CustomTurbine, 

137 { 

138 "property_package": methods.PropertyPackage(), 

139 "power_property_package": methods.PowerPropertyPackage(), 

140 "dynamic": methods.Constant(False), 

141 "calculation_method": methods.Constant("Tsat_willans"), 

142 } 

143 ), 

144 "bs_turbine": UnitModelConstructor( 

145 CustomTurbine, 

146 { 

147 "property_package": methods.PropertyPackage(), 

148 "power_property_package": methods.PowerPropertyPackage(), 

149 "dynamic": methods.Constant(False), 

150 "calculation_method": methods.Constant("BPST_willans"), 

151 } 

152 ), 

153 "cs_turbine": UnitModelConstructor( 

154 CustomTurbine, 

155 { 

156 "property_package": methods.PropertyPackage(), 

157 "power_property_package": methods.PowerPropertyPackage(), 

158 "dynamic": methods.Constant(False), 

159 "calculation_method": methods.Constant("CT_willans"), 

160 } 

161 ), 

162 "mixer": UnitModelConstructor( 

163 Mixer, 

164 { 

165 "property_package": methods.PropertyPackage(), 

166 "num_inlets": methods.Value(), 

167 }, 

168 ), 

169 "Tank": UnitModelConstructor( 

170 CustomTank, 

171 { 

172 "property_package": methods.PropertyPackage(), 

173 "dynamic": methods.Value(), 

174 "has_holdup": methods.Value(), 

175 "tank_type": methods.Constant("vertical_cylindrical_tank"), 

176 "has_heat_transfer": methods.Constant(True), 

177 } 

178 ), 

179 "heatExchanger": UnitModelConstructor( 

180 CustomHeatExchanger, 

181 { 

182 "delta_temperature_callback": methods.Constant( 

183 delta_temperature_underwood_callback 

184 ), 

185 "hot_side": methods.Dictionary( 

186 { 

187 "property_package": methods.PropertyPackage(), 

188 "has_pressure_change": methods.Constant(True), 

189 } 

190 ), 

191 "cold_side": methods.Dictionary( 

192 { 

193 "property_package": methods.PropertyPackage(), 

194 "has_pressure_change": methods.Constant(True), 

195 } 

196 ), 

197 "dynamic": methods.Constant(False), 

198 }, 

199 ), 

200 "heatPump": UnitModelConstructor( 

201 SimpleHeatPump, 

202 { 

203 "source": methods.Dictionary( 

204 { 

205 "property_package": methods.PropertyPackage(), 

206 "has_pressure_change": methods.Constant(False), 

207 } 

208 ), 

209 "sink": methods.Dictionary( 

210 { 

211 "property_package": methods.PropertyPackage(), 

212 "has_pressure_change": methods.Constant(False), 

213 } 

214 ), 

215 "dynamic": methods.Constant(False), 

216 }, 

217 ), 

218 "valve": UnitModelConstructor( 

219 ValveWrapper, # type: ignore 

220 { 

221 "property_package": methods.PropertyPackage(), 

222 "enable_coefficients": methods.Value(), 

223 "valve_function": methods.Value(), 

224 "dynamic": methods.Constant(False), 

225 }, 

226 ), 

227 "cooler": UnitModelConstructor( 

228 CustomCooler, 

229 { 

230 "property_package": methods.PropertyPackage(), 

231 "has_pressure_change": methods.Value(), 

232 "dynamic": methods.Constant(False), 

233 }, 

234 ), 

235 "splitter": UnitModelConstructor( 

236 CustomSeparator, 

237 { 

238 "property_package": methods.PropertyPackage(), 

239 "num_outlets": methods.Value(), 

240 }, 

241 ), 

242 "phaseSeparator": UnitModelConstructor( 

243 CustomSeparator, 

244 { 

245 "property_package": methods.PropertyPackage(), 

246 "num_outlets": methods.Value(), 

247 "split_basis": methods.Constant( 

248 SplittingType.phaseFlow 

249 ), 

250 "energy_split_basis": methods.Constant( 

251 EnergySplittingType.enthalpy_split 

252 ), 

253 }, 

254 ), 

255 "compoundSeparator": UnitModelConstructor( 

256 CustomSeparator, 

257 { 

258 "property_package": methods.PropertyPackage(), 

259 "num_outlets": methods.Value(), 

260 "split_basis": methods.Constant( 

261 SplittingType.componentFlow 

262 ), 

263 }, 

264 ), 

265 "machineLearningBlock": UnitModelConstructor(PySMOModel, { 

266 "property_package": methods.PropertyPackage(), 

267 "model": methods.Value(), 

268 "ids": methods.Value(), 

269 "unitopNames": methods.Value(), 

270 "num_inlets": methods.Value(), 

271 "num_outlets": methods.Value(), 

272 }), 

273 "link": UnitModelConstructor( 

274 Link, 

275 { 

276 "property_package": methods.PowerPropertyPackage(), 

277 }, 

278 ), 

279 "solar": UnitModelConstructor( 

280 Solar, 

281 { 

282 "property_package": methods.PowerPropertyPackage(), 

283 }, 

284 ), 

285 "wind": UnitModelConstructor( 

286 Wind, 

287 { 

288 "property_package": methods.PowerPropertyPackage(), 

289 }, 

290 ), 

291 "energy_mixer": UnitModelConstructor( 

292 EnergyMixer, 

293 { 

294 "property_package": methods.PowerPropertyPackage(), 

295 "num_inlets": methods.Value(), 

296 }, 

297 ), 

298 "bus": UnitModelConstructor( 

299 Bus, 

300 { 

301 "property_package": methods.PowerPropertyPackage(), 

302 "num_inlets": methods.Value(), 

303 

304 }, 

305 ), 

306 "acBus": UnitModelConstructor( 

307 acBus, 

308 { 

309 "property_package": methods.acPropertyPackage(), 

310 "num_inlets": methods.Value(), 

311 "num_outlets": methods.Value(), 

312 }, 

313 ), 

314 "transmissionLine": UnitModelConstructor( 

315 transmissionLine, 

316 { 

317 "property_package": methods.PowerPropertyPackage(), 

318 "num_inlets": methods.Value(), 

319 "num_outlets": methods.Value(), 

320 }, 

321 ), 

322 "load": UnitModelConstructor( 

323 Load, 

324 { 

325 "property_package": methods.PowerPropertyPackage(), 

326 }, 

327 ), 

328 "hydro": UnitModelConstructor( 

329 Hydro, 

330 { 

331 "property_package": methods.PowerPropertyPackage(), 

332 }, 

333 ), 

334 

335 "transformer": UnitModelConstructor( 

336 Transformer, 

337 { 

338 "property_package": methods.PowerPropertyPackage(), 

339 }, 

340 ), 

341 "storage": UnitModelConstructor( 

342 Storage, 

343 { 

344 "property_package": methods.PowerPropertyPackage(), 

345 "has_holdup": methods.Value(), 

346 "dynamic": methods.Value(), 

347 }, 

348 ), 

349 "direct_steam_injection": UnitModelConstructor( 

350 Dsi, 

351 { 

352 "property_package": methods.PropertyPackage(), 

353 "steam_property_package": methods.PropertyPackage(), 

354 }, 

355 ), 

356 "translator": UnitModelConstructor( 

357 GenericTranslator, 

358 { 

359 "inlet_property_package": methods.PropertyPackage(), 

360 "outlet_property_package": methods.PropertyPackage(), 

361 "translator_type": methods.Value(), 

362 }, 

363 ), 

364 "pid_controller": UnitModelConstructor( 

365 PIDController2, 

366 { 

367 "dynamic": methods.Constant(True), 

368 "controller_type": methods.Constant(ControllerType.PI), 

369 "calculate_initial_integral": methods.Constant(True), 

370 "mv_bound_type": methods.Constant(ControllerMVBoundType.SMOOTH_BOUND), 

371 }, 

372 ), 

373 "custom_variable": UnitModelConstructor( 

374 CustomVariable, 

375 {}, 

376 ), 

377 "grid": UnitModelConstructor( 

378 Grid, 

379 { 

380 "property_package": methods.PowerPropertyPackage(), 

381 }, 

382 ), 

383 "integration": UnitModelConstructor( 

384 IntegrationBlock, 

385 { 

386 }, 

387 ), 

388 "stoich_hda": UnitModelConstructor( 

389 HDAStoichiometricReactor, 

390 { 

391 "property_package": methods.ReactorPropertyPackage(), 

392 "has_heat_transfer": methods.Constant(True), 

393 #"has_heat_of_reaction": methods.Value(), 

394 #"has_pressure_change": methods.Value(), 

395 "has_holdup": methods.Constant(False), 

396 "dynamic": methods.Constant(False), 

397 "reaction_package": methods.ReactionPackage(), 

398 }, 

399 ), 

400 "stoich_hda": UnitModelConstructor( 

401 HDAStoichiometricReactor, 

402 { 

403 "property_package": methods.ReactorPropertyPackage(), 

404 "has_heat_transfer": methods.Constant(True), 

405 #"has_heat_of_reaction": methods.Value(), 

406 #"has_pressure_change": methods.Value(), 

407 "has_holdup": methods.Constant(False), 

408 "dynamic": methods.Constant(False), 

409 "reaction_package": methods.ReactionPackage(), 

410 }, 

411 ), 

412 "RCT_CSTR": UnitModelConstructor( 

413 CSTR, 

414 { 

415 "property_package": methods.ReactorPropertyPackage(), 

416 "has_heat_transfer": methods.Value(), 

417 "has_heat_of_reaction": methods.Value(), 

418 "has_pressure_change": methods.Value(), 

419 "has_holdup": methods.Value(), 

420 "dynamic": methods.Value(), 

421 "reaction_package": methods.ReactionPackage(), 

422 }, 

423 

424 ), 

425 "energy_splitter": UnitModelConstructor( 

426 EnergySplitter, 

427 { 

428 "property_package": methods.PowerPropertyPackage(), 

429 "num_inlets": methods.Value(), 

430 "num_outlets": methods.Value(), 

431 }, 

432 ), 

433 "mdb": UnitModelConstructor( 

434 MDB, 

435 { 

436 "property_package": methods.PowerPropertyPackage(), 

437 "num_inlets": methods.Value(), 

438 "num_outlets": methods.Value(), 

439 } 

440 ), 

441 "header": UnitModelConstructor( 

442 SteamHeader, 

443 { 

444 "property_package": methods.PropertyPackage(), 

445 "num_inlets": methods.Value(), 

446 "num_outlets": methods.Value(), 

447 }, 

448 ), 

449 "simple_header": UnitModelConstructor( 

450 simple_header, 

451 { 

452 "property_package": methods.PropertyPackage(), 

453 "num_inlets": methods.Value(), 

454 "num_outlets": methods.Value(), 

455 }, 

456 ), 

457 "heat_exchanger_1d": UnitModelConstructor( 

458 HeatExchanger1DWrapper, 

459 { 

460 "hot_side": methods.Dictionary({ 

461 "property_package": methods.PropertyPackage(), 

462 "transformation_method": methods.Value(), 

463 "transformation_scheme": methods.Value(), 

464 "has_pressure_change": methods.Constant(False), 

465 }), 

466 "cold_side": methods.Dictionary({ 

467 "property_package": methods.PropertyPackage(), 

468 "transformation_method": methods.Value(), 

469 "transformation_scheme": methods.Value(), 

470 "has_pressure_change": methods.Constant(False), 

471 }), 

472 "finite_elements": methods.Value(), 

473 "collocation_points": methods.Value(), 

474 "flow_type": methods.Value(), 

475 }, 

476 ), 

477 "steam_user": UnitModelConstructor( 

478 SteamUser, 

479 { 

480 "property_package": methods.PropertyPackage(), 

481 } 

482 ), 

483 "desuperheater": UnitModelConstructor( 

484 Desuperheater, 

485 { 

486 "property_package": methods.PropertyPackage(), 

487 } 

488 ), 

489 "heat_exchanger_ntu": UnitModelConstructor( 

490 HeatExchangerEffectiveness, 

491 { 

492 "hot_side": methods.Dictionary( 

493 { 

494 "property_package": methods.PropertyPackage(), 

495 "has_pressure_change": methods.Constant(True), 

496 } 

497 ), 

498 "cold_side": methods.Dictionary( 

499 { 

500 "property_package": methods.PropertyPackage(), 

501 "has_pressure_change": methods.Constant(True), 

502 } 

503 ), 

504 "dynamic": methods.Constant(False), 

505 }, 

506 ), 

507 "waterpipe": UnitModelConstructor( 

508 WaterPipe, 

509 { 

510 "property_package": methods.PropertyPackage(), 

511 "has_heat_transfer": methods.Constant(False), 

512 "has_pressure_change": methods.Constant(True), 

513 } 

514 ), 

515 "heat_exchanger_lc": UnitModelConstructor( 

516 HeatExchangerLumpedCapacitance, 

517 { 

518 "hot_side": methods.Dictionary( 

519 { 

520 "property_package": methods.PropertyPackage(), 

521 "has_pressure_change": methods.Constant(False), 

522 } 

523 ), 

524 "cold_side": methods.Dictionary( 

525 { 

526 "property_package": methods.PropertyPackage(), 

527 "has_pressure_change": methods.Constant(False), 

528 } 

529 ), 

530 "dynamic_heat_balance": methods.Constant(False), 

531 }, 

532 ), 

533 "plate_heat_exchanger": UnitModelConstructor( 

534 PlateHeatExchanger, 

535 { 

536 "hot_side": methods.Dictionary( 

537 { 

538 "property_package": methods.PropertyPackage(), 

539 "has_pressure_change": methods.Constant(True), 

540 } 

541 ), 

542 "cold_side": methods.Dictionary( 

543 { 

544 "property_package": methods.PropertyPackage(), 

545 "has_pressure_change": methods.Constant(True), 

546 } 

547 ), 

548 "dynamic": methods.Constant(False), 

549 }, 

550 ), 

551 "reverse_osmosis_0d": UnitModelConstructor( 

552 ReverseOsmosis0D, 

553 { 

554 "property_package": methods.PropertyPackage(), 

555 }, 

556 ), 

557 "pressure_exchanger": UnitModelConstructor( 

558 PressureExchanger, 

559 { 

560 "property_package": methods.PropertyPackage(), 

561 }, 

562 ), 

563 }