OGS
CreateFlowAndTemperatureControl.cpp
Go to the documentation of this file.
1
12
13#include "BaseLib/Algorithm.h"
14#include "BaseLib/ConfigTree.h"
15#include "BuildingPowerCurves.h"
18
19namespace ProcessLib
20{
21namespace HeatTransportBHE
22{
23namespace BHE
24{
26 std::optional<BaseLib::ConfigTree> const& config,
27 std::map<std::string,
28 std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
29 curves)
30{
31 auto const& power_curve = *BaseLib::getOrError(
32 curves,
34 config->getConfigParameter<std::string>("power_curve"),
35 "Required power curve not found.");
36
37 auto const& cop_curve = *BaseLib::getOrError(
38 curves,
40 config->getConfigParameter<std::string>("cop_curve"),
41 "Required cop curve not found.");
42
43 return BuildingPowerCurves{power_curve, cop_curve};
44};
45
47 std::optional<BaseLib::ConfigTree> const& cooling_config,
48 std::map<std::string,
49 std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
50 curves)
51{
52 if (
53 cooling_config->getConfigParameter<bool>("active", false))
54 {
55 return createBuildingPowerCurvesStruct(cooling_config, curves);
56 }
57 else
58 {
59 return std::ref(*BaseLib::getOrError(
60 curves,
62 cooling_config->getConfigParameter<std::string>("power_curve"),
63 "Required cooling power curve not found."));
64 }
65};
66
68 BuildingPowerCurves const& heating,
69 BuildingPowerCurves const& hot_water,
70 CoolingVariant const& cooling,
71 MathLib::PiecewiseLinearInterpolation const& flow_rate_curve,
72 RefrigerantProperties const& refrigerant,
73 double const flow_rate_min,
74 double const power_min)
75{
76 if (std::holds_alternative<BuildingPowerCurves>(cooling))
77 {
79 std::in_place_type<
81 heating,
82 hot_water,
83 std::get<BuildingPowerCurves>(cooling),
84 flow_rate_curve,
85 refrigerant.specific_heat_capacity,
86 refrigerant.density,
87 flow_rate_min,
88 power_min};
89 }
90 else
91 {
93 std::in_place_type<
95 heating,
96 hot_water,
97 std::get<
98 std::reference_wrapper<MathLib::PiecewiseLinearInterpolation>>(
99 cooling)
100 .get(),
101 flow_rate_curve,
102 refrigerant.specific_heat_capacity,
103 refrigerant.density,
104 flow_rate_min,
105 power_min};
106 }
107};
108
110 BuildingPowerCurves const& heating,
111 BuildingPowerCurves const& /*hot_water*/,
112 CoolingVariant const& cooling,
113 MathLib::PiecewiseLinearInterpolation const& flow_rate_curve,
114 RefrigerantProperties const& refrigerant,
115 double const flow_rate_min,
116 double const power_min)
117{
118 if (std::holds_alternative<BuildingPowerCurves>(cooling))
119 {
121 std::in_place_type<BuildingPowerCurveActiveCoolingCurveFlowCurve>,
122 heating,
123 std::get<BuildingPowerCurves>(cooling),
124 flow_rate_curve,
125 refrigerant.specific_heat_capacity,
126 refrigerant.density,
127 flow_rate_min,
128 power_min};
129 }
130 else
131 {
133 std::in_place_type<BuildingPowerCurvePassiveCoolingCurveFlowCurve>,
134 heating,
135 std::get<
136 std::reference_wrapper<MathLib::PiecewiseLinearInterpolation>>(
137 cooling)
138 .get(),
139 flow_rate_curve,
140 refrigerant.specific_heat_capacity,
141 refrigerant.density,
142 flow_rate_min,
143 power_min};
144 }
145};
146
148 BuildingPowerCurves const& /*heating*/,
149 BuildingPowerCurves const& hot_water,
150 CoolingVariant const& cooling,
151 MathLib::PiecewiseLinearInterpolation const& flow_rate_curve,
152 RefrigerantProperties const& refrigerant,
153 double const flow_rate_min,
154 double const power_min)
155{
156 if (std::holds_alternative<BuildingPowerCurves>(cooling))
157 {
159 std::in_place_type<BuildingPowerCurveActiveCoolingCurveFlowCurve>,
160 hot_water,
161 std::get<BuildingPowerCurves>(cooling),
162 flow_rate_curve,
163 refrigerant.specific_heat_capacity,
164 refrigerant.density,
165 flow_rate_min,
166 power_min};
167 }
168 else
169 {
171 std::in_place_type<BuildingPowerCurvePassiveCoolingCurveFlowCurve>,
172 hot_water,
173 std::get<
174 std::reference_wrapper<MathLib::PiecewiseLinearInterpolation>>(
175 cooling)
176 .get(),
177 flow_rate_curve,
178 refrigerant.specific_heat_capacity,
179 refrigerant.density,
180 flow_rate_min,
181 power_min};
182 }
183};
184
186 BuildingPowerCurves const& /*heating*/,
187 BuildingPowerCurves const& /*hot_water*/,
188 CoolingVariant const& cooling,
189 MathLib::PiecewiseLinearInterpolation const& flow_rate_curve,
190 RefrigerantProperties const& refrigerant,
191 double const flow_rate_min,
192 double const power_min)
193{
194 if (std::holds_alternative<BuildingPowerCurves>(cooling))
195 {
197 std::in_place_type<ActiveCoolingCurveFlowCurve>,
198 std::get<BuildingPowerCurves>(cooling),
199 flow_rate_curve,
200 refrigerant.specific_heat_capacity,
201 refrigerant.density,
202 flow_rate_min,
203 power_min};
204 }
205 else
206 {
208 std::in_place_type<PowerCurveFlowCurve>,
209 std::get<
210 std::reference_wrapper<MathLib::PiecewiseLinearInterpolation>>(
211 cooling)
212 .get(),
213 flow_rate_curve,
214 refrigerant.specific_heat_capacity,
215 refrigerant.density,
216 flow_rate_min,
217 power_min};
218 }
219};
220
222 std::function<FlowAndTemperatureControl(
223 BuildingPowerCurves const&, // heating
224 BuildingPowerCurves const&, // hot water
225 CoolingVariant const&, // cooling
226 MathLib::PiecewiseLinearInterpolation const&, // flow rate curve
228 double const, // flow rate min
229 double const)>; // power min
230
231const std::map<std::tuple<bool, bool, bool>, // heating, hot_water,
232 // cooling
235 {{true, true, true}, &createHeatingHotWaterCooling},
236 {{true, true, false},
237 [](auto const& heating, auto const& hot_water, auto const& /*cooling*/,
238 auto const& flow_rate_curve, auto const& refrigerant,
239 auto const flow_rate_min, auto const power_min)
240 {
242 std::in_place_type<BuildingPowerCurveHotWaterCurveFlowCurve>,
243 heating,
244 hot_water,
245 flow_rate_curve,
246 refrigerant.specific_heat_capacity,
247 refrigerant.density,
248 flow_rate_min,
249 power_min};
250 }},
251 {{true, false, true}, &createHeatingCooling},
252 {{false, true, true}, &createHotWaterCooling},
253 {{true, false, false},
254 [](auto const& heating, auto const& /*hot_water*/,
255 auto const& /*cooling*/, auto const& flow_rate_curve,
256 auto const& refrigerant, auto const flow_rate_min,
257 auto const power_min)
258 {
260 std::in_place_type<BuildingPowerCurveFlowCurve>,
261 heating,
262 flow_rate_curve,
263 refrigerant.specific_heat_capacity,
264 refrigerant.density,
265 flow_rate_min,
266 power_min};
267 }},
268 {{false, true, false},
269 [](auto const& /*heating*/, auto const& hot_water,
270 auto const& /*cooling*/, auto const& flow_rate_curve,
271 auto const& refrigerant, auto const flow_rate_min,
272 auto const power_min)
273 {
275 std::in_place_type<BuildingPowerCurveFlowCurve>,
276 hot_water,
277 flow_rate_curve,
278 refrigerant.specific_heat_capacity,
279 refrigerant.density,
280 flow_rate_min,
281 power_min};
282 }},
283 {{false, false, true}, &createCooling}};
284
286 std::optional<BaseLib::ConfigTree> const& heating_config,
287 std::optional<BaseLib::ConfigTree> const& hot_water_config,
288 std::optional<BaseLib::ConfigTree> const& cooling_config,
289 std::map<std::string,
290 std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
291 curves,
292 MathLib::PiecewiseLinearInterpolation const& flow_rate_curve,
293 RefrigerantProperties const& refrigerant,
294 double const flow_rate_min,
295 double const power_min)
296{
297 std::optional<BuildingPowerCurves> building_heating_curves;
298 std::optional<BuildingPowerCurves> building_hot_water_curves;
299 std::optional<CoolingVariant> building_cooling_curves;
300
301 bool heating = false;
302 bool hot_water = false;
303 bool cooling = false;
304
305 if (heating_config)
306 {
307 building_heating_curves.emplace(
308 createBuildingPowerCurvesStruct(heating_config, curves));
309 heating = true;
310 }
311 if (hot_water_config)
312 {
313 building_hot_water_curves.emplace(
314 createBuildingPowerCurvesStruct(hot_water_config, curves));
315 hot_water = true;
316 }
317 if (cooling_config)
318 {
319 building_cooling_curves.emplace(
320 createCoolingVariant(cooling_config, curves));
321 cooling = true;
322 }
323 auto key = std::make_tuple(heating, hot_water, cooling);
324
325 auto it = advancedBuildingPowerCurvesFlowCurve.find(key);
327 OGS_FATAL(
328 "AdvancedBuildingPowerCurvesFlowCurve combination is not "
329 "implemented.");
330 auto factory = it->second;
331
332 return factory(*building_heating_curves,
333 *building_hot_water_curves,
334 *building_cooling_curves,
335 flow_rate_curve,
336 refrigerant,
337 flow_rate_min,
338 power_min);
339}
341 BaseLib::ConfigTree const& config,
342 std::map<std::string,
343 std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
344 curves,
345 RefrigerantProperties const& refrigerant)
346{
348 auto const type = config.getConfigParameter<std::string>("type");
349
350 auto const flow_rate_min =
352 config.getConfigParameter<double>("flow_rate_min", 1e-6);
354 auto const power_min = config.getConfigParameter<double>("power_min", 1e-3);
355 if (type == "TemperatureCurveConstantFlow")
356 {
358 auto const flow_rate = config.getConfigParameter<double>("flow_rate");
359
360 auto const& temperature_curve = *BaseLib::getOrError(
361 curves,
363 config.getConfigParameter<std::string>("temperature_curve"),
364 "Required temperature curve not found.");
365
366 return TemperatureCurveConstantFlow{flow_rate, temperature_curve,
367 flow_rate_min};
368 }
369 if (type == "TemperatureCurveFlowCurve")
370 {
371 auto const& flow_rate_curve = *BaseLib::getOrError(
372 curves,
374 config.getConfigParameter<std::string>("flow_rate_curve"),
375 "Required flow curve not found.");
376
377 auto const& temperature_curve = *BaseLib::getOrError(
378 curves,
380 config.getConfigParameter<std::string>("temperature_curve"),
381 "Required temperature curve not found.");
382
383 return TemperatureCurveFlowCurve{flow_rate_curve, temperature_curve,
384 flow_rate_min};
385 }
386 if (type == "FixedPowerConstantFlow")
387 {
389 auto const power = config.getConfigParameter<double>("power");
390
392 auto const flow_rate = config.getConfigParameter<double>("flow_rate");
393
394 return FixedPowerConstantFlow{flow_rate,
395 power,
396 refrigerant.specific_heat_capacity,
397 refrigerant.density,
398 flow_rate_min,
399 power_min};
400 }
401
402 if (type == "FixedPowerFlowCurve")
403 {
404 auto const& flow_rate_curve = *BaseLib::getOrError(
405 curves,
407 config.getConfigParameter<std::string>("flow_rate_curve"),
408 "Required flow rate curve not found.");
409
411 auto const power = config.getConfigParameter<double>("power");
412
413 return FixedPowerFlowCurve{flow_rate_curve,
414 power,
415 refrigerant.specific_heat_capacity,
416 refrigerant.density,
417 flow_rate_min,
418 power_min};
419 }
420
421 if (type == "PowerCurveConstantFlow")
422 {
423 auto const& power_curve = *BaseLib::getOrError(
424 curves,
426 config.getConfigParameter<std::string>("power_curve"),
427 "Required power curve not found.");
428
430 auto const flow_rate = config.getConfigParameter<double>("flow_rate");
431
432 return PowerCurveConstantFlow{power_curve,
433 flow_rate,
434 refrigerant.specific_heat_capacity,
435 refrigerant.density,
436 flow_rate_min,
437 power_min};
438 }
439
440 if (type == "PowerCurveFlowCurve")
441 {
442 auto const& power_curve = *BaseLib::getOrError(
443 curves,
445 config.getConfigParameter<std::string>("power_curve"),
446 "Required power curve not found.");
447
448 auto const& flow_rate_curve = *BaseLib::getOrError(
449 curves,
451 config.getConfigParameter<std::string>("flow_rate_curve"),
452 "Required flow rate curve not found.");
453
454 return PowerCurveFlowCurve{power_curve,
455 flow_rate_curve,
456 refrigerant.specific_heat_capacity,
457 refrigerant.density,
458 flow_rate_min,
459 power_min};
460 }
461
462 if (type == "AdvancedBuildingPowerCurvesFlowCurve")
463 {
464 // add a heating, hot water and cooling config as optional to handle
465 // different combinations later
466 auto const& heating_config =
469 "heating"); // Optional, take care if it is not present
470
471 // add a heating config to differ between different types
472 auto const& hot_water_config =
475 "hot_water"); // Optional, take care if it is not present
476
477 // add a heating config to differ between different types
478 auto const& cooling_config =
481 "cooling"); // Optional, take care if it is not present
482
483 auto const& flow_rate_curve = *BaseLib::getOrError(
484 curves,
486 config.getConfigParameter<std::string>("flow_rate_curve"),
487 "Required flow rate curve not found.");
488
489 return createAdvancedBuildingPowerCurvesFlowCurve(heating_config,
490 hot_water_config,
491 cooling_config,
492 curves,
493 flow_rate_curve,
494 refrigerant,
495 flow_rate_min,
496 power_min);
497 }
498 OGS_FATAL("FlowAndTemperatureControl type '{:s}' is not implemented.",
499 type);
500}
501} // namespace BHE
502} // namespace HeatTransportBHE
503} // namespace ProcessLib
#define OGS_FATAL(...)
Definition Error.h:26
Definition of the PiecewiseLinearInterpolation class.
std::optional< ConfigTree > getConfigSubtreeOptional(std::string const &root) const
T getConfigParameter(std::string const &param) const
OGS_NO_DANGLING Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
Definition Algorithm.h:118
const std::map< std::tuple< bool, bool, bool >, FactoryAdvancedBuildingCurvesFlowCurve > advancedBuildingPowerCurvesFlowCurve
FlowAndTemperatureControl createCooling(BuildingPowerCurves const &, BuildingPowerCurves const &, CoolingVariant const &cooling, MathLib::PiecewiseLinearInterpolation const &flow_rate_curve, RefrigerantProperties const &refrigerant, double const flow_rate_min, double const power_min)
std::variant< TemperatureCurveConstantFlow, TemperatureCurveFlowCurve, FixedPowerConstantFlow, FixedPowerFlowCurve, PowerCurveConstantFlow, PowerCurveFlowCurve, BuildingPowerCurveConstantFlow, BuildingPowerCurveHotWaterCurveActiveCoolingCurveFlowCurve, BuildingPowerCurveHotWaterCurvePassiveCoolingCurveFlowCurve, BuildingPowerCurveHotWaterCurveFlowCurve, BuildingPowerCurveActiveCoolingCurveFlowCurve, BuildingPowerCurvePassiveCoolingCurveFlowCurve, BuildingPowerCurveFlowCurve, ActiveCoolingCurveFlowCurve > FlowAndTemperatureControl
FlowAndTemperatureControl createHeatingHotWaterCooling(BuildingPowerCurves const &heating, BuildingPowerCurves const &hot_water, CoolingVariant const &cooling, MathLib::PiecewiseLinearInterpolation const &flow_rate_curve, RefrigerantProperties const &refrigerant, double const flow_rate_min, double const power_min)
FlowAndTemperatureControl createHotWaterCooling(BuildingPowerCurves const &, BuildingPowerCurves const &hot_water, CoolingVariant const &cooling, MathLib::PiecewiseLinearInterpolation const &flow_rate_curve, RefrigerantProperties const &refrigerant, double const flow_rate_min, double const power_min)
FlowAndTemperatureControl createHeatingCooling(BuildingPowerCurves const &heating, BuildingPowerCurves const &, CoolingVariant const &cooling, MathLib::PiecewiseLinearInterpolation const &flow_rate_curve, RefrigerantProperties const &refrigerant, double const flow_rate_min, double const power_min)
FlowAndTemperatureControl createAdvancedBuildingPowerCurvesFlowCurve(std::optional< BaseLib::ConfigTree > const &heating_config, std::optional< BaseLib::ConfigTree > const &hot_water_config, std::optional< BaseLib::ConfigTree > const &cooling_config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, MathLib::PiecewiseLinearInterpolation const &flow_rate_curve, RefrigerantProperties const &refrigerant, double const flow_rate_min, double const power_min)
FlowAndTemperatureControl createFlowAndTemperatureControl(BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, RefrigerantProperties const &refrigerant)
BuildingPowerCurves createBuildingPowerCurvesStruct(std::optional< BaseLib::ConfigTree > const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::variant< BuildingPowerCurves, std::reference_wrapper< MathLib::PiecewiseLinearInterpolation > > CoolingVariant
CoolingVariant createCoolingVariant(std::optional< BaseLib::ConfigTree > const &cooling_config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::function< FlowAndTemperatureControl( BuildingPowerCurves const &, BuildingPowerCurves const &, CoolingVariant const &, MathLib::PiecewiseLinearInterpolation const &, RefrigerantProperties const &, double const, double const)> FactoryAdvancedBuildingCurvesFlowCurve