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 ..custom.custom_cooler import CustomCooler 

61 

62class UnitModelConstructor: 

63 """ 

64 Schema for adapter library items 

65 """ 

66 

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

68 # idaes model constructor 

69 self.model_constructor: type = model_constructor 

70 # dictionary of argument parsers 

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

72 

73 

74 

75""" 

76A dictionary of adapters for the idaes model constructors 

77""" 

78AdapterLibrary: dict[str, UnitModelConstructor] = { 

79 "pump": UnitModelConstructor( 

80 CustomPump, 

81 { 

82 "property_package": methods.PropertyPackage(), 

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

84 "power_property_package": methods.PowerPropertyPackage(), 

85 

86 }, 

87 ), 

88 "heater": UnitModelConstructor( 

89 DynamicHeater, 

90 { 

91 "property_package": methods.PropertyPackage(), 

92 "has_pressure_change": methods.Value(), 

93 "dynamic": methods.Value(), 

94 "has_holdup": methods.Value(), 

95 }, 

96 ), 

97 "compressor": UnitModelConstructor( 

98 CustomCompressor, 

99 { 

100 "property_package": methods.PropertyPackage(), 

101 "power_property_package": methods.PowerPropertyPackage(), 

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

103 }, 

104 ), 

105 "turbine": UnitModelConstructor( 

106 CustomTurbine, 

107 { 

108 "property_package": methods.PropertyPackage(), 

109 "power_property_package": methods.PowerPropertyPackage(), 

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

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

112 }, 

113 ), 

114 "willans_turbine": UnitModelConstructor( 

115 CustomTurbine, 

116 { 

117 "property_package": methods.PropertyPackage(), 

118 "power_property_package": methods.PowerPropertyPackage(), 

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

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

121 }, 

122 ), 

123 "pl_turbine": UnitModelConstructor( 

124 CustomTurbine, 

125 { 

126 "property_package": methods.PropertyPackage(), 

127 "power_property_package": methods.PowerPropertyPackage(), 

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

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

130 } 

131 ), 

132 "dts_turbine": UnitModelConstructor( 

133 CustomTurbine, 

134 { 

135 "property_package": methods.PropertyPackage(), 

136 "power_property_package": methods.PowerPropertyPackage(), 

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

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

139 } 

140 ), 

141 "bs_turbine": UnitModelConstructor( 

142 CustomTurbine, 

143 { 

144 "property_package": methods.PropertyPackage(), 

145 "power_property_package": methods.PowerPropertyPackage(), 

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

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

148 } 

149 ), 

150 "cs_turbine": UnitModelConstructor( 

151 CustomTurbine, 

152 { 

153 "property_package": methods.PropertyPackage(), 

154 "power_property_package": methods.PowerPropertyPackage(), 

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

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

157 } 

158 ), 

159 "mixer": UnitModelConstructor( 

160 Mixer, 

161 { 

162 "property_package": methods.PropertyPackage(), 

163 "num_inlets": methods.Value(), 

164 }, 

165 ), 

166 "Tank": UnitModelConstructor( 

167 CustomTank, 

168 { 

169 "property_package": methods.PropertyPackage(), 

170 "dynamic": methods.Value(), 

171 "has_holdup": methods.Value(), 

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

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

174 } 

175 ), 

176 "heatExchanger": UnitModelConstructor( 

177 CustomHeatExchanger, 

178 { 

179 "delta_temperature_callback": methods.Constant( 

180 delta_temperature_underwood_callback 

181 ), 

182 "hot_side": methods.Dictionary( 

183 { 

184 "property_package": methods.PropertyPackage(), 

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

186 } 

187 ), 

188 "cold_side": methods.Dictionary( 

189 { 

190 "property_package": methods.PropertyPackage(), 

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

192 } 

193 ), 

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

195 }, 

196 ), 

197 "heatPump": UnitModelConstructor( 

198 SimpleHeatPump, 

199 { 

200 "source": methods.Dictionary( 

201 { 

202 "property_package": methods.PropertyPackage(), 

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

204 } 

205 ), 

206 "sink": methods.Dictionary( 

207 { 

208 "property_package": methods.PropertyPackage(), 

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

210 } 

211 ), 

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

213 }, 

214 ), 

215 "valve": UnitModelConstructor( 

216 ValveWrapper, # type: ignore 

217 { 

218 "property_package": methods.PropertyPackage(), 

219 "enable_coefficients": methods.Value(), 

220 "valve_function": methods.Value(), 

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

222 }, 

223 ), 

224 "cooler": UnitModelConstructor( 

225 CustomCooler, 

226 { 

227 "property_package": methods.PropertyPackage(), 

228 "has_pressure_change": methods.Value(), 

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

230 }, 

231 ), 

232 "splitter": UnitModelConstructor( 

233 CustomSeparator, 

234 { 

235 "property_package": methods.PropertyPackage(), 

236 "num_outlets": methods.Value(), 

237 }, 

238 ), 

239 "phaseSeparator": UnitModelConstructor( 

240 CustomSeparator, 

241 { 

242 "property_package": methods.PropertyPackage(), 

243 "num_outlets": methods.Value(), 

244 "split_basis": methods.Constant( 

245 SplittingType.phaseFlow 

246 ), 

247 "energy_split_basis": methods.Constant( 

248 EnergySplittingType.enthalpy_split 

249 ), 

250 }, 

251 ), 

252 "compoundSeparator": UnitModelConstructor( 

253 CustomSeparator, 

254 { 

255 "property_package": methods.PropertyPackage(), 

256 "num_outlets": methods.Value(), 

257 "split_basis": methods.Constant( 

258 SplittingType.componentFlow 

259 ), 

260 }, 

261 ), 

262 "machineLearningBlock": UnitModelConstructor(PySMOModel, { 

263 "property_package": methods.PropertyPackage(), 

264 "model": methods.Value(), 

265 "ids": methods.Value(), 

266 "unitopNames": methods.Value(), 

267 "num_inlets": methods.Value(), 

268 "num_outlets": methods.Value(), 

269 }), 

270 "link": UnitModelConstructor( 

271 Link, 

272 { 

273 "property_package": methods.PowerPropertyPackage(), 

274 }, 

275 ), 

276 "solar": UnitModelConstructor( 

277 Solar, 

278 { 

279 "property_package": methods.PowerPropertyPackage(), 

280 }, 

281 ), 

282 "wind": UnitModelConstructor( 

283 Wind, 

284 { 

285 "property_package": methods.PowerPropertyPackage(), 

286 }, 

287 ), 

288 "energy_mixer": UnitModelConstructor( 

289 EnergyMixer, 

290 { 

291 "property_package": methods.PowerPropertyPackage(), 

292 "num_inlets": methods.Value(), 

293 }, 

294 ), 

295 "bus": UnitModelConstructor( 

296 Bus, 

297 { 

298 "property_package": methods.PowerPropertyPackage(), 

299 "num_inlets": methods.Value(), 

300 

301 }, 

302 ), 

303 "acBus": UnitModelConstructor( 

304 acBus, 

305 { 

306 "property_package": methods.acPropertyPackage(), 

307 "num_inlets": methods.Value(), 

308 "num_outlets": methods.Value(), 

309 }, 

310 ), 

311 "transmissionLine": UnitModelConstructor( 

312 transmissionLine, 

313 { 

314 "property_package": methods.PowerPropertyPackage(), 

315 "num_inlets": methods.Value(), 

316 "num_outlets": methods.Value(), 

317 }, 

318 ), 

319 "load": UnitModelConstructor( 

320 Load, 

321 { 

322 "property_package": methods.PowerPropertyPackage(), 

323 }, 

324 ), 

325 "hydro": UnitModelConstructor( 

326 Hydro, 

327 { 

328 "property_package": methods.PowerPropertyPackage(), 

329 }, 

330 ), 

331 

332 "transformer": UnitModelConstructor( 

333 Transformer, 

334 { 

335 "property_package": methods.PowerPropertyPackage(), 

336 }, 

337 ), 

338 "storage": UnitModelConstructor( 

339 Storage, 

340 { 

341 "property_package": methods.PowerPropertyPackage(), 

342 "has_holdup": methods.Value(), 

343 "dynamic": methods.Value(), 

344 }, 

345 ), 

346 "direct_steam_injection": UnitModelConstructor( 

347 Dsi, 

348 { 

349 "property_package": methods.PropertyPackage(), 

350 "steam_property_package": methods.PropertyPackage(), 

351 }, 

352 ), 

353 "translator": UnitModelConstructor( 

354 GenericTranslator, 

355 { 

356 "inlet_property_package": methods.PropertyPackage(), 

357 "outlet_property_package": methods.PropertyPackage(), 

358 "translator_type": methods.Value(), 

359 }, 

360 ), 

361 "pid_controller": UnitModelConstructor( 

362 PIDController2, 

363 { 

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

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

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

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

368 }, 

369 ), 

370 "custom_variable": UnitModelConstructor( 

371 CustomVariable, 

372 {}, 

373 ), 

374 "grid": UnitModelConstructor( 

375 Grid, 

376 { 

377 "property_package": methods.PowerPropertyPackage(), 

378 }, 

379 ), 

380 "integration": UnitModelConstructor( 

381 IntegrationBlock, 

382 { 

383 }, 

384 ), 

385 "stoich_hda": UnitModelConstructor( 

386 HDAStoichiometricReactor, 

387 { 

388 "property_package": methods.ReactorPropertyPackage(), 

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

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

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

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

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

394 "reaction_package": methods.ReactionPackage(), 

395 }, 

396 ), 

397 "stoich_hda": UnitModelConstructor( 

398 HDAStoichiometricReactor, 

399 { 

400 "property_package": methods.ReactorPropertyPackage(), 

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

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

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

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

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

406 "reaction_package": methods.ReactionPackage(), 

407 }, 

408 ), 

409 "RCT_CSTR": UnitModelConstructor( 

410 CSTR, 

411 { 

412 "property_package": methods.ReactorPropertyPackage(), 

413 "has_heat_transfer": methods.Value(), 

414 "has_heat_of_reaction": methods.Value(), 

415 "has_pressure_change": methods.Value(), 

416 "has_holdup": methods.Value(), 

417 "dynamic": methods.Value(), 

418 "reaction_package": methods.ReactionPackage(), 

419 }, 

420 

421 ), 

422 "energy_splitter": UnitModelConstructor( 

423 EnergySplitter, 

424 { 

425 "property_package": methods.PowerPropertyPackage(), 

426 "num_inlets": methods.Value(), 

427 "num_outlets": methods.Value(), 

428 }, 

429 ), 

430 "mdb": UnitModelConstructor( 

431 MDB, 

432 { 

433 "property_package": methods.PowerPropertyPackage(), 

434 "num_inlets": methods.Value(), 

435 "num_outlets": methods.Value(), 

436 } 

437 ), 

438 "header": UnitModelConstructor( 

439 SteamHeader, 

440 { 

441 "property_package": methods.PropertyPackage(), 

442 "num_inlets": methods.Value(), 

443 "num_outlets": methods.Value(), 

444 }, 

445 ), 

446 "simple_header": UnitModelConstructor( 

447 simple_header, 

448 { 

449 "property_package": methods.PropertyPackage(), 

450 "num_inlets": methods.Value(), 

451 "num_outlets": methods.Value(), 

452 }, 

453 ), 

454 "heat_exchanger_1d": UnitModelConstructor( 

455 HeatExchanger1DWrapper, 

456 { 

457 "hot_side": methods.Dictionary({ 

458 "property_package": methods.PropertyPackage(), 

459 "transformation_method": methods.Value(), 

460 "transformation_scheme": methods.Value(), 

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

462 }), 

463 "cold_side": methods.Dictionary({ 

464 "property_package": methods.PropertyPackage(), 

465 "transformation_method": methods.Value(), 

466 "transformation_scheme": methods.Value(), 

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

468 }), 

469 "finite_elements": methods.Value(), 

470 "collocation_points": methods.Value(), 

471 "flow_type": methods.Value(), 

472 }, 

473 ), 

474 "steam_user": UnitModelConstructor( 

475 SteamUser, 

476 { 

477 "property_package": methods.PropertyPackage(), 

478 } 

479 ), 

480 "desuperheater": UnitModelConstructor( 

481 Desuperheater, 

482 { 

483 "property_package": methods.PropertyPackage(), 

484 } 

485 ), 

486 "heat_exchanger_ntu": UnitModelConstructor( 

487 HeatExchangerEffectiveness, 

488 { 

489 "hot_side": methods.Dictionary( 

490 { 

491 "property_package": methods.PropertyPackage(), 

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

493 } 

494 ), 

495 "cold_side": methods.Dictionary( 

496 { 

497 "property_package": methods.PropertyPackage(), 

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

499 } 

500 ), 

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

502 }, 

503 ), 

504 "waterpipe": UnitModelConstructor( 

505 WaterPipe, 

506 { 

507 "property_package": methods.PropertyPackage(), 

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

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

510 } 

511 ), 

512 "heat_exchanger_lc": UnitModelConstructor( 

513 HeatExchangerLumpedCapacitance, 

514 { 

515 "hot_side": methods.Dictionary( 

516 { 

517 "property_package": methods.PropertyPackage(), 

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

519 } 

520 ), 

521 "cold_side": methods.Dictionary( 

522 { 

523 "property_package": methods.PropertyPackage(), 

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

525 } 

526 ), 

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

528 }, 

529 ) 

530 }