Coverage for tests/rcx25/extraction_results_test.py: 100%

1# 

2# -------------------------------------------------------------------------------- 

3# SPDX-FileCopyrightText: 2024-2025 Martin Jan Köhler and Harald Pretl 

4# Johannes Kepler University, Institute for Integrated Circuits. 

5# 

6# This file is part of KPEX  

7# (see https://github.com/martinjankoehler/klayout-pex). 

8# 

9# This program is free software: you can redistribute it and/or modify 

10# it under the terms of the GNU General Public License as published by 

11# the Free Software Foundation, either version 3 of the License, or 

12# (at your option) any later version. 

13# 

14# This program is distributed in the hope that it will be useful, 

15# but WITHOUT ANY WARRANTY; without even the implied warranty of 

16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

17# GNU General Public License for more details. 

18# 

19# You should have received a copy of the GNU General Public License 

20# along with this program. If not, see <http://www.gnu.org/licenses/>. 

21# SPDX-License-Identifier: GPL-3.0-or-later 

22# -------------------------------------------------------------------------------- 

23# 

24import allure 

25import pytest 

26import unittest 

27 

28from klayout_pex.rcx25.extraction_results import * 

29 

30 

31@allure.parent_suite("Unit Tests") 

32class NetCoupleKeyTest(unittest.TestCase): 

33 def test_normed_ascending(self): 

34 k = NetCoupleKey('net_bottom', 'net_top') 

35 obtained_k = k.normed() 

36 expected_k = NetCoupleKey('net_bottom', 'net_top') 

37 self.assertEqual(expected_k, obtained_k) 

38 

39 def test_normed_descending(self): 

40 k = NetCoupleKey('net_top', 'net_bottom') 

41 obtained_k = k.normed() 

42 expected_k = NetCoupleKey('net_bottom', 'net_top') 

43 self.assertEqual(expected_k, obtained_k) 

44 

45 

46@allure.parent_suite("Unit Tests") 

47class CellExtractionResultsTest(unittest.TestCase): 

48 def test_summarize_overlap(self): 

49 results = CellExtractionResults(cell_name='Cell') 

50 

51 ovk1a = OverlapKey(layer_top='m2', 

52 net_top='net_top', 

53 layer_bot='m1', 

54 net_bot='net_bot') 

55 

56 ovk1b = OverlapKey(layer_top='m2', 

57 net_top='net_top', 

58 layer_bot='m1', 

59 net_bot='net_bot') 

60 

61 ovk2 = OverlapKey(layer_top='m3', 

62 net_top='net_top', 

63 layer_bot='m1', 

64 net_bot='net_bot') 

65 

66 ovc1a = OverlapCap(key=ovk1a, 

67 cap_value=10.0, 

68 shielded_area=20.0, 

69 unshielded_area=30.0, 

70 tech_spec=None) 

71 

72 ovc1b = OverlapCap(key=ovk1b, 

73 cap_value=11.0, 

74 shielded_area=21.0, 

75 unshielded_area=31.0, 

76 tech_spec=None) 

77 

78 ovc2 = OverlapCap(key=ovk2, 

79 cap_value=12.0, 

80 shielded_area=22.0, 

81 unshielded_area=32.0, 

82 tech_spec=None) 

83 

84 results.add_overlap_cap(ovc1a) 

85 results.add_overlap_cap(ovc2) 

86 results.add_overlap_cap(ovc1b) 

87 

88 summary = results.summarize() 

89 obtained_cap_value = summary.capacitances[NetCoupleKey('net_top', 'net_bot').normed()] 

90 expected_cap_value = ovc1a.cap_value + ovc1b.cap_value + ovc2.cap_value 

91 self.assertEqual(expected_cap_value, obtained_cap_value) 

92 

93 def test_summarize_sidewall(self): 

94 results = CellExtractionResults(cell_name='Cell') 

95 

96 k1a = SidewallKey(layer='m2', 

97 net1='net1', 

98 net2='net2') 

99 

100 k1b = SidewallKey(layer='m2', 

101 net1='net2', 

102 net2='net1') 

103 

104 k2 = SidewallKey(layer='m3', 

105 net1='net1', 

106 net2='net3') 

107 

108 c1a = SidewallCap(key=k1a, 

109 cap_value=10.0, 

110 distance=20.0, 

111 length=30.0, 

112 tech_spec=None) 

113 

114 c1b = SidewallCap(key=k1b, 

115 cap_value=11.0, 

116 distance=21.0, 

117 length=31.0, 

118 tech_spec=None) 

119 

120 c2 = SidewallCap(key=k2, 

121 cap_value=12.0, 

122 distance=22.0, 

123 length=32.0, 

124 tech_spec=None) 

125 

126 results.add_sidewall_cap(c1a) 

127 results.add_sidewall_cap(c1b) 

128 results.add_sidewall_cap(c2) 

129 

130 summary = results.summarize() 

131 

132 obtained_cap_value = summary.capacitances[NetCoupleKey('net1', 'net2').normed()] 

133 expected_cap_value = c1a.cap_value + c1b.cap_value 

134 self.assertEqual(expected_cap_value, obtained_cap_value) 

135 

136 obtained_cap_value = summary.capacitances[NetCoupleKey('net1', 'net3').normed()] 

137 expected_cap_value = c2.cap_value 

138 self.assertEqual(expected_cap_value, obtained_cap_value) 

139 

140 def test_summarize_sideoverlap(self): 

141 results = CellExtractionResults(cell_name='Cell') 

142 

143 k1a = SideOverlapKey(layer_inside='m2', 

144 net_inside='net2', 

145 layer_outside='m1', 

146 net_outside='net1') 

147 

148 k1b = SideOverlapKey(layer_inside='m1', 

149 net_inside='net1', 

150 layer_outside='m2', 

151 net_outside='net2') 

152 

153 k2 = SideOverlapKey(layer_inside='m3', 

154 net_inside='net3', 

155 layer_outside='m1', 

156 net_outside='net1') 

157 

158 c1a = SideOverlapCap(key=k1a, 

159 cap_value=10.0) 

160 

161 c1b = SideOverlapCap(key=k1b, 

162 cap_value=10.0) 

163 

164 c2 = SideOverlapCap(key=k2, 

165 cap_value=10.0) 

166 

167 results.add_sideoverlap_cap(c1a) 

168 results.add_sideoverlap_cap(c1b) 

169 results.add_sideoverlap_cap(c2) 

170 

171 summary = results.summarize() 

172 

173 obtained_cap_value = summary.capacitances[NetCoupleKey('net1', 'net2').normed()] 

174 expected_cap_value = c1a.cap_value + c1b.cap_value 

175 self.assertEqual(expected_cap_value, obtained_cap_value) 

176 

177 obtained_cap_value = summary.capacitances[NetCoupleKey('net1', 'net3').normed()] 

178 expected_cap_value = c2.cap_value 

179 self.assertEqual(expected_cap_value, obtained_cap_value)