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

1import unittest 

2 

3from bim2sim.plugins.PluginAixLib.bim2sim_aixlib import LoadLibrariesAixLib 

4from bim2sim.elements.mapping.units import ureg 

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

6 

7 

8class TestAixLibExport(TestStandardLibraryExports): 

9 

10 @classmethod 

11 def setUpClass(cls) -> None: 

12 super().setUpClass() 

13 lib_aixlib = LoadLibrariesAixLib(cls.playground) 

14 cls.loaded_libs = lib_aixlib.run()[0] 

15 

16 @unittest.skip 

17 def test_boiler_export(self): 

18 raise NotImplementedError 

19 

20 def test_radiator_export(self): 

21 graph = self.helper.get_simple_radiator() 

22 answers = () 

23 reads = (self.loaded_libs, graph) 

24 modelica_model = self.run_task(answers, reads) 

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

26 ('flow_temperature', 'T_a_nominal'), 

27 ('return_temperature', 'T_b_nominal')] 

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

29 self.run_parameter_test(graph, modelica_model, parameters, 

30 expected_units) 

31 

32 def test_pump_export(self): 

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

34 answers = () 

35 reads = (self.loaded_libs, graph) 

36 modelica_model = self.run_task(answers, reads) 

37 element = graph.elements[0] 

38 V_flow = element.rated_volume_flow.to(ureg.m ** 3 / ureg.s).magnitude 

39 dp = element.rated_pressure_difference.to(ureg.pascal).magnitude 

40 expected_string = (f"per(pressure(" 

41 f"V_flow={{{0 * V_flow},{1 * V_flow},{2 * V_flow}}}," 

42 f"dp={{{2 * dp},{1 * dp},{0 * dp}}}" 

43 f"))") 

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

45 

46 def test_consumer_export(self): 

47 graph, _ = self.helper.get_simple_consumer() 

48 answers = () 

49 reads = (self.loaded_libs, graph) 

50 modelica_model = self.run_task(answers, reads) 

51 parameters = [('rated_power', 'Q_flow_fixed')] 

52 expected_units = [ureg.watt] 

53 self.run_parameter_test(graph, modelica_model, parameters, 

54 expected_units) 

55 

56 @unittest.skip 

57 def test_consumer_heating_distributor_module_export(self): 

58 raise NotImplementedError 

59 

60 @unittest.skip 

61 def test_consumer_boiler_aggregation_export(self): 

62 raise NotImplementedError 

63 

64 @unittest.skip 

65 def test_consumer_distributor_export(self): 

66 raise NotImplementedError 

67 

68 def test_three_way_valve_export(self): 

69 graph = self.helper.get_simple_three_way_valve() 

70 answers = (1 * ureg.kg / ureg.s,) 

71 reads = (self.loaded_libs, graph) 

72 modelica_model = self.run_task(answers, reads) 

73 parameters = [('nominal_pressure_difference', 'dpValve_nominal'), 

74 ('nominal_mass_flow_rate', 'm_flow_nominal')] 

75 expected_units = [ureg.pascal, ureg.kg / ureg.s] 

76 self.run_parameter_test(graph, modelica_model, parameters, 

77 expected_units) 

78 

79 def test_heat_pump_export(self): 

80 graph = self.helper.get_simple_heat_pump() 

81 answers = () 

82 reads = (self.loaded_libs, graph) 

83 modelica_model = self.run_task(answers, reads) 

84 parameters = [('rated_power', 'Q_useNominal')] 

85 expected_units = [ureg.watt] 

86 self.run_parameter_test(graph, modelica_model, parameters, 

87 expected_units) 

88 

89 def test_chiller_export(self): 

90 graph = self.helper.get_simple_chiller() 

91 answers = () 

92 reads = (self.loaded_libs, graph) 

93 modelica_model = self.run_task(answers, reads) 

94 parameters = [('rated_power', 'Q_useNominal')] 

95 expected_units = [ureg.watt] 

96 self.run_parameter_test(graph, modelica_model, parameters, 

97 expected_units) 

98 

99 @unittest.skip 

100 def test_consumer_CHP_export(self): 

101 raise NotImplementedError 

102 

103 def test_storage_export(self): 

104 graph = self.helper.get_simple_storage() 

105 answers = () 

106 reads = (self.loaded_libs, graph) 

107 modelica_model = self.run_task(answers, reads) 

108 parameters = [('height', 'hTank'), ('diameter', 'dTank')] 

109 expected_units = [ureg.meter, ureg.meter] 

110 element = graph.elements[0] 

111 expected_values = [ 

112 element.attributes[param[0]][0].to(expected_units[index]).magnitude 

113 for index, param in enumerate(parameters)] 

114 param_value_pairs = [f"{param[1]}={value}" for param, value in 

115 zip(parameters, expected_values)] 

116 expected_string = f"data({','.join(param_value_pairs)})" 

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