Coverage for bim2sim/plugins/PluginHKESim/test/unit/kernel/task/test_export.py: 0%

1import tempfile 

2import unittest 

3 

4from bim2sim.elements.aggregation.hvac_aggregations import \ 

5 ConsumerHeatingDistributorModule 

6from bim2sim.elements.mapping.units import ureg 

7from bim2sim.kernel.decision.decisionhandler import DebugDecisionHandler 

8from bim2sim.plugins.PluginHKESim.bim2sim_hkesim import LoadLibrariesHKESim 

9from test.unit.tasks.hvac.test_export import TestStandardLibraryExports 

10 

11 

12class TestHKESimExport(TestStandardLibraryExports): 

13 

14 @classmethod 

15 def setUpClass(cls) -> None: 

16 super().setUpClass() 

17 # Load libraries as these are required for export 

18 lib_hkesim = LoadLibrariesHKESim(cls.playground) 

19 cls.loaded_libs = lib_hkesim.run()[0] 

20 

21 def test_boiler_export(self): 

22 graph = self.helper.get_simple_boiler() 

23 answers = () 

24 reads = (self.loaded_libs, graph) 

25 modelica_model = self.run_task(answers, reads) 

26 parameters = [('rated_power', 'Q_nom'), 

27 ('return_temperature', 'T_set')] 

28 expected_units = [ureg.watt, ureg.kelvin] 

29 self.run_parameter_test(graph, modelica_model, parameters, 

30 expected_units) 

31 

32 def test_radiator_export(self): 

33 graph = self.helper.get_simple_radiator() 

34 answers = () 

35 reads = (self.loaded_libs, graph) 

36 modelica_model = self.run_task(answers, reads) 

37 parameters = [('rated_power', 'Q_flow_nominal'), 

38 ('return_temperature', 'Tout_max')] 

39 expected_units = [ureg.watt, ureg.kelvin] 

40 self.run_parameter_test(graph, modelica_model, parameters, 

41 expected_units) 

42 

43 def test_pump_export(self): 

44 graph, _ = self.helper.get_simple_pump() 

45 answers = () 

46 reads = (self.loaded_libs, graph) 

47 modelica_model = self.run_task(answers, reads) 

48 parameters = [('rated_height', 'head_set'), 

49 ('rated_volume_flow', 'Vflow_set'), 

50 ('rated_power', 'P_nom')] 

51 expected_units = [ureg.meter, ureg.meter ** 3 / ureg.hour, ureg.watt] 

52 self.run_parameter_test(graph, modelica_model, parameters, 

53 expected_units) 

54 

55 @unittest.skip 

56 def test_three_way_valve_export(self): 

57 # TODO: there are no parameters to test for 

58 raise NotImplementedError 

59 

60 def test_consumer_heating_distributor_module_export(self): 

61 # Set up the test graph and model 

62 graph = self.helper.get_simple_consumer_heating_distributor_module() 

63 answers = () 

64 reads = (self.loaded_libs, graph) 

65 modelica_model = self.run_task(answers, reads) 

66 # Get the ConsumerHeatingDistributorModule element 

67 element = next(element for element in graph.elements 

68 if isinstance(element, 

69 ConsumerHeatingDistributorModule)) 

70 

71 # Get parameter values from element 

72 flow_temp_0 = element.flow_temperature[0].magnitude 

73 return_temp_0 = element.return_temperature[0].magnitude 

74 flow_temp_1 = element.flow_temperature[1].magnitude 

75 return_temp_1 = element.return_temperature[1].magnitude 

76 rated_power_0 = element.rated_power[0].to(ureg.watt).magnitude 

77 rated_power_1 = element.rated_power[1].to(ureg.watt).magnitude 

78 

79 # Define the expected parameter strings in modelica model code 

80 expected_strings = [ 

81 f"Tconsumer={{{flow_temp_0},{return_temp_0}}}", 

82 f"Tconsumer1={{{flow_temp_0},{return_temp_0}}}", 

83 f"Tconsumer2={{{flow_temp_1},{return_temp_1}}}", 

84 f"c1Qflow_nom={rated_power_0}", 

85 f"c2Qflow_nom={rated_power_1}", 

86 "useHydraulicSeparator=false", 

87 "c1TControl=false", 

88 "c2TControl=false", 

89 "c1OpenEnd=false", 

90 "c1OpenEnd=false", 

91 "isConsumer2=true"] 

92 

93 # Assert that each expected string is in the modelica_model code 

94 for expected_string in expected_strings: 

95 self.assertIn(expected_string, modelica_model[0].code()) 

96 

97 def test_boiler_module_export(self): 

98 graph = self.helper.get_simple_generator_one_fluid() 

99 answers = () 

100 reads = (self.loaded_libs, graph) 

101 modelica_model = self.run_task(answers, reads) 

102 element = graph.elements[0] 

103 rated_power = element.rated_power.to(ureg.watt).magnitude 

104 flow_temp = element.flow_temperature.magnitude 

105 return_temp = element.return_temperature.magnitude 

106 expected_strings = [ 

107 f"Theating={{{flow_temp},{return_temp}}}", 

108 f"Qflow_nom={rated_power}", 

109 ] 

110 for expected_string in expected_strings: 

111 self.assertIn(expected_string, modelica_model[0].code()) 

112 

113 def test_heat_pump_export(self): 

114 graph = self.helper.get_simple_heat_pump() 

115 answers = () 

116 reads = (self.loaded_libs, graph) 

117 modelica_model = self.run_task(answers, reads) 

118 parameters = [('rated_power', 'Qcon_nom')] 

119 expected_units = [ureg.watt] 

120 self.run_parameter_test(graph, modelica_model, parameters, 

121 expected_units) 

122 

123 def test_chiller_export(self): 

124 graph = self.helper.get_simple_chiller() 

125 answers = () 

126 reads = (self.loaded_libs, graph) 

127 modelica_model = self.run_task(answers, reads) 

128 parameters = [('rated_power', 'Qev_nom'), 

129 ('nominal_COP', 'EER_nom')] 

130 expected_units = [ureg.watt, ureg.dimensionless] 

131 self.run_parameter_test(graph, modelica_model, parameters, 

132 expected_units) 

133 

134 def test_chp_export(self): 

135 graph = self.helper.get_simple_chp() 

136 answers = () 

137 reads = (self.loaded_libs, graph) 

138 modelica_model = self.run_task(answers, reads) 

139 parameters = [('rated_power', 'P_nom')] 

140 expected_units = [ureg.watt] 

141 self.run_parameter_test(graph, modelica_model, parameters, 

142 expected_units) 

143 

144 def test_cooling_tower_export(self): 

145 graph = self.helper.get_simple_cooling_tower() 

146 answers = () 

147 reads = (self.loaded_libs, graph) 

148 modelica_model = self.run_task(answers, reads) 

149 parameters = [('rated_power', 'Qflow_nom')] 

150 expected_units = [ureg.watt] 

151 self.run_parameter_test(graph, modelica_model, parameters, 

152 expected_units)