Coverage for backend/idaes_service/solver/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 idaes_service.solver.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 

62 

63class UnitModelConstructor: 

64 """ 

65 Schema for adapter library items 

66 """ 

67 

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

69 # idaes model constructor 

70 self.model_constructor: type = model_constructor 

71 # dictionary of argument parsers 

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

73 

74 

75 

76""" 

77A dictionary of adapters for the idaes model constructors 

78""" 

79AdapterLibrary: dict[str, UnitModelConstructor] = { 

80 "pump": UnitModelConstructor( 

81 CustomPump, 

82 { 

83 "property_package": methods.PropertyPackage(), 

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

85 "power_property_package": methods.PowerPropertyPackage(), 

86 

87 }, 

88 ), 

89 "heater": UnitModelConstructor( 

90 DynamicHeater, 

91 { 

92 "property_package": methods.PropertyPackage(), 

93 "has_pressure_change": methods.Value(), 

94 "dynamic": methods.Value(), 

95 "has_holdup": methods.Value(), 

96 }, 

97 ), 

98 "compressor": UnitModelConstructor( 

99 CustomCompressor, 

100 { 

101 "property_package": methods.PropertyPackage(), 

102 "power_property_package": methods.PowerPropertyPackage(), 

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

104 }, 

105 ), 

106 "turbine": UnitModelConstructor( 

107 CustomTurbine, 

108 { 

109 "property_package": methods.PropertyPackage(), 

110 "power_property_package": methods.PowerPropertyPackage(), 

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

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

113 }, 

114 ), 

115 "willans_turbine": UnitModelConstructor( 

116 CustomTurbine, 

117 { 

118 "property_package": methods.PropertyPackage(), 

119 "power_property_package": methods.PowerPropertyPackage(), 

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

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

122 }, 

123 ), 

124 "pl_turbine": UnitModelConstructor( 

125 CustomTurbine, 

126 { 

127 "property_package": methods.PropertyPackage(), 

128 "power_property_package": methods.PowerPropertyPackage(), 

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

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

131 } 

132 ), 

133 "dts_turbine": UnitModelConstructor( 

134 CustomTurbine, 

135 { 

136 "property_package": methods.PropertyPackage(), 

137 "power_property_package": methods.PowerPropertyPackage(), 

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

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

140 } 

141 ), 

142 "bs_turbine": UnitModelConstructor( 

143 CustomTurbine, 

144 { 

145 "property_package": methods.PropertyPackage(), 

146 "power_property_package": methods.PowerPropertyPackage(), 

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

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

149 } 

150 ), 

151 "cs_turbine": UnitModelConstructor( 

152 CustomTurbine, 

153 { 

154 "property_package": methods.PropertyPackage(), 

155 "power_property_package": methods.PowerPropertyPackage(), 

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

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

158 } 

159 ), 

160 "mixer": UnitModelConstructor( 

161 Mixer, 

162 { 

163 "property_package": methods.PropertyPackage(), 

164 "num_inlets": methods.Value(), 

165 }, 

166 ), 

167 "Tank": UnitModelConstructor( 

168 CustomTank, 

169 { 

170 "property_package": methods.PropertyPackage(), 

171 "dynamic": methods.Value(), 

172 "has_holdup": methods.Value(), 

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

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

175 } 

176 ), 

177 "heatExchanger": UnitModelConstructor( 

178 CustomHeatExchanger, 

179 { 

180 "delta_temperature_callback": methods.Constant( 

181 delta_temperature_underwood_callback 

182 ), 

183 "hot_side": methods.Dictionary( 

184 { 

185 "property_package": methods.PropertyPackage(), 

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

187 } 

188 ), 

189 "cold_side": methods.Dictionary( 

190 { 

191 "property_package": methods.PropertyPackage(), 

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

193 } 

194 ), 

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

196 }, 

197 ), 

198 "heatPump": UnitModelConstructor( 

199 SimpleHeatPump, 

200 { 

201 "source": methods.Dictionary( 

202 { 

203 "property_package": methods.PropertyPackage(), 

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

205 } 

206 ), 

207 "sink": methods.Dictionary( 

208 { 

209 "property_package": methods.PropertyPackage(), 

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

211 } 

212 ), 

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

214 }, 

215 ), 

216 "valve": UnitModelConstructor( 

217 ValveWrapper, # type: ignore 

218 { 

219 "property_package": methods.PropertyPackage(), 

220 "enable_coefficients": methods.Value(), 

221 "valve_function": methods.Value(), 

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

223 }, 

224 ), 

225 "cooler": UnitModelConstructor( 

226 CustomCooler, 

227 { 

228 "property_package": methods.PropertyPackage(), 

229 "has_pressure_change": methods.Value(), 

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

231 }, 

232 ), 

233 "splitter": UnitModelConstructor( 

234 CustomSeparator, 

235 { 

236 "property_package": methods.PropertyPackage(), 

237 "num_outlets": methods.Value(), 

238 }, 

239 ), 

240 "phaseSeparator": UnitModelConstructor( 

241 CustomSeparator, 

242 { 

243 "property_package": methods.PropertyPackage(), 

244 "num_outlets": methods.Value(), 

245 "split_basis": methods.Constant( 

246 SplittingType.phaseFlow 

247 ), 

248 "energy_split_basis": methods.Constant( 

249 EnergySplittingType.enthalpy_split 

250 ), 

251 }, 

252 ), 

253 "compoundSeparator": UnitModelConstructor( 

254 CustomSeparator, 

255 { 

256 "property_package": methods.PropertyPackage(), 

257 "num_outlets": methods.Value(), 

258 "split_basis": methods.Constant( 

259 SplittingType.componentFlow 

260 ), 

261 }, 

262 ), 

263 "machineLearningBlock": UnitModelConstructor(PySMOModel, { 

264 "property_package": methods.PropertyPackage(), 

265 "model": methods.Value(), 

266 "ids": methods.Value(), 

267 "unitopNames": methods.Value(), 

268 "num_inlets": methods.Value(), 

269 "num_outlets": methods.Value(), 

270 }), 

271 "link": UnitModelConstructor( 

272 Link, 

273 { 

274 "property_package": methods.PowerPropertyPackage(), 

275 }, 

276 ), 

277 "solar": UnitModelConstructor( 

278 Solar, 

279 { 

280 "property_package": methods.PowerPropertyPackage(), 

281 }, 

282 ), 

283 "wind": UnitModelConstructor( 

284 Wind, 

285 { 

286 "property_package": methods.PowerPropertyPackage(), 

287 }, 

288 ), 

289 "energy_mixer": UnitModelConstructor( 

290 EnergyMixer, 

291 { 

292 "property_package": methods.PowerPropertyPackage(), 

293 "num_inlets": methods.Value(), 

294 }, 

295 ), 

296 "bus": UnitModelConstructor( 

297 Bus, 

298 { 

299 "property_package": methods.PowerPropertyPackage(), 

300 "num_inlets": methods.Value(), 

301 

302 }, 

303 ), 

304 "acBus": UnitModelConstructor( 

305 acBus, 

306 { 

307 "property_package": methods.acPropertyPackage(), 

308 "num_inlets": methods.Value(), 

309 "num_outlets": methods.Value(), 

310 }, 

311 ), 

312 "transmissionLine": UnitModelConstructor( 

313 transmissionLine, 

314 { 

315 "property_package": methods.PowerPropertyPackage(), 

316 "num_inlets": methods.Value(), 

317 "num_outlets": methods.Value(), 

318 }, 

319 ), 

320 "load": UnitModelConstructor( 

321 Load, 

322 { 

323 "property_package": methods.PowerPropertyPackage(), 

324 }, 

325 ), 

326 "hydro": UnitModelConstructor( 

327 Hydro, 

328 { 

329 "property_package": methods.PowerPropertyPackage(), 

330 }, 

331 ), 

332 

333 "transformer": UnitModelConstructor( 

334 Transformer, 

335 { 

336 "property_package": methods.PowerPropertyPackage(), 

337 }, 

338 ), 

339 "storage": UnitModelConstructor( 

340 Storage, 

341 { 

342 "property_package": methods.PowerPropertyPackage(), 

343 "has_holdup": methods.Value(), 

344 "dynamic": methods.Value(), 

345 }, 

346 ), 

347 "direct_steam_injection": UnitModelConstructor( 

348 Dsi, 

349 { 

350 "property_package": methods.PropertyPackage(), 

351 "steam_property_package": methods.PropertyPackage(), 

352 }, 

353 ), 

354 "translator": UnitModelConstructor( 

355 GenericTranslator, 

356 { 

357 "inlet_property_package": methods.PropertyPackage(), 

358 "outlet_property_package": methods.PropertyPackage(), 

359 "translator_type": methods.Value(), 

360 }, 

361 ), 

362 "pid_controller": UnitModelConstructor( 

363 PIDController2, 

364 { 

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

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

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

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

369 }, 

370 ), 

371 "custom_variable": UnitModelConstructor( 

372 CustomVariable, 

373 {}, 

374 ), 

375 "grid": UnitModelConstructor( 

376 Grid, 

377 { 

378 "property_package": methods.PowerPropertyPackage(), 

379 }, 

380 ), 

381 "integration": UnitModelConstructor( 

382 IntegrationBlock, 

383 { 

384 }, 

385 ), 

386 "stoich_hda": UnitModelConstructor( 

387 HDAStoichiometricReactor, 

388 { 

389 "property_package": methods.ReactorPropertyPackage(), 

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

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

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

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

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

395 "reaction_package": methods.ReactionPackage(), 

396 }, 

397 ), 

398 "stoich_hda": UnitModelConstructor( 

399 HDAStoichiometricReactor, 

400 { 

401 "property_package": methods.ReactorPropertyPackage(), 

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

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

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

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

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

407 "reaction_package": methods.ReactionPackage(), 

408 }, 

409 ), 

410 "RCT_CSTR": UnitModelConstructor( 

411 CSTR, 

412 { 

413 "property_package": methods.ReactorPropertyPackage(), 

414 "has_heat_transfer": methods.Value(), 

415 "has_heat_of_reaction": methods.Value(), 

416 "has_pressure_change": methods.Value(), 

417 "has_holdup": methods.Value(), 

418 "dynamic": methods.Value(), 

419 "reaction_package": methods.ReactionPackage(), 

420 }, 

421 

422 ), 

423 "energy_splitter": UnitModelConstructor( 

424 EnergySplitter, 

425 { 

426 "property_package": methods.PowerPropertyPackage(), 

427 "num_inlets": methods.Value(), 

428 "num_outlets": methods.Value(), 

429 }, 

430 ), 

431 "mdb": UnitModelConstructor( 

432 MDB, 

433 { 

434 "property_package": methods.PowerPropertyPackage(), 

435 "num_inlets": methods.Value(), 

436 "num_outlets": methods.Value(), 

437 } 

438 ), 

439 "header": UnitModelConstructor( 

440 SteamHeader, 

441 { 

442 "property_package": methods.PropertyPackage(), 

443 "num_inlets": methods.Value(), 

444 "num_outlets": methods.Value(), 

445 }, 

446 ), 

447 "simple_header": UnitModelConstructor( 

448 simple_header, 

449 { 

450 "property_package": methods.PropertyPackage(), 

451 "num_inlets": methods.Value(), 

452 "num_outlets": methods.Value(), 

453 }, 

454 ), 

455 "heat_exchanger_1d": UnitModelConstructor( 

456 HeatExchanger1DWrapper, 

457 { 

458 "hot_side": methods.Dictionary({ 

459 "property_package": methods.PropertyPackage(), 

460 "transformation_method": methods.Value(), 

461 "transformation_scheme": methods.Value(), 

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

463 }), 

464 "cold_side": methods.Dictionary({ 

465 "property_package": methods.PropertyPackage(), 

466 "transformation_method": methods.Value(), 

467 "transformation_scheme": methods.Value(), 

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

469 }), 

470 "finite_elements": methods.Value(), 

471 "collocation_points": methods.Value(), 

472 "flow_type": methods.Value(), 

473 }, 

474 ), 

475 "steam_user": UnitModelConstructor( 

476 SteamUser, 

477 { 

478 "property_package": methods.PropertyPackage(), 

479 } 

480 ), 

481 "desuperheater": UnitModelConstructor( 

482 Desuperheater, 

483 { 

484 "property_package": methods.PropertyPackage(), 

485 } 

486 ), 

487 "heat_exchanger_ntu": UnitModelConstructor( 

488 HeatExchangerEffectiveness, 

489 { 

490 "hot_side": methods.Dictionary( 

491 { 

492 "property_package": methods.PropertyPackage(), 

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

494 } 

495 ), 

496 "cold_side": methods.Dictionary( 

497 { 

498 "property_package": methods.PropertyPackage(), 

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

500 } 

501 ), 

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

503 }, 

504 ), 

505 "waterpipe": UnitModelConstructor( 

506 WaterPipe, 

507 { 

508 "property_package": methods.PropertyPackage(), 

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

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

511 } 

512 ), 

513 "heat_exchanger_lc": UnitModelConstructor( 

514 HeatExchangerLumpedCapacitance, 

515 { 

516 "hot_side": methods.Dictionary( 

517 { 

518 "property_package": methods.PropertyPackage(), 

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

520 } 

521 ), 

522 "cold_side": methods.Dictionary( 

523 { 

524 "property_package": methods.PropertyPackage(), 

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

526 } 

527 ), 

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

529 }, 

530 ), 

531 "plate_heat_exchanger": UnitModelConstructor( 

532 PlateHeatExchanger, 

533 { 

534 "hot_side": methods.Dictionary( 

535 { 

536 "property_package": methods.PropertyPackage(), 

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

538 } 

539 ), 

540 "cold_side": methods.Dictionary( 

541 { 

542 "property_package": methods.PropertyPackage(), 

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

544 } 

545 ), 

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

547 }, 

548 ), 

549 }