Coverage for klayout_pex/magic/magic_log_analyzer.py: 26%

1#! /usr/bin/env python3 

2# 

3# -------------------------------------------------------------------------------- 

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

5# Johannes Kepler University, Institute for Integrated Circuits. 

6# 

7# This file is part of KPEX 

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

9# 

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

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

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

13# (at your option) any later version. 

14# 

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

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

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

18# GNU General Public License for more details. 

19# 

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

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

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

23# -------------------------------------------------------------------------------- 

24# 

25 

26import argparse 

27import os 

28from pathlib import Path 

29import re 

30import sys 

31from typing import * 

32 

33from rich_argparse import RichHelpFormatter 

34 

35import klayout.db as kdb 

36import klayout.rdb as rdb 

37 

38from klayout_pex.magic.magic_ext_file_parser import parse_magic_pex_run 

39from klayout_pex.magic.magic_ext_data_structures import MagicPEXRun, CellExtData 

40 

41PROGRAM_NAME = "magic_log_analyzer" 

42 

43 

44class MagicLogAnalyzer: 

45 def __init__(self, 

46 magic_pex_run: MagicPEXRun, 

47 report: rdb.ReportDatabase, 

48 dbu: float): 

49 self.magic_pex_run = magic_pex_run 

50 self.report = report 

51 self.magic_category = self.report.create_category('MAGIC Extraction') 

52 self.dbu = dbu 

53 

54 def analyze(self): 

55 for cell, cell_data in self.magic_pex_run.cells.items(): 

56 self.analyze_cell(cell=cell, cell_data=cell_data) 

57 

58 def analyze_cell(self, 

59 cell: str, 

60 cell_data: CellExtData): 

61 rdb_cell = self.report.create_cell(name=cell) 

62 ports_cat = self.report.create_category(parent=self.magic_category, name='Ports') 

63 nodes_cat = self.report.create_category(parent=self.magic_category, name='Nodes') 

64 devices_cat = self.report.create_category(parent=self.magic_category, name='Devices') 

65 rnodes_cat = self.report.create_category(parent=self.magic_category, name='Resistor Nodes') 

66 resistors_cat = self.report.create_category(parent=self.magic_category, name='Resistors') 

67 

68 dbu_to_um = 200.0 

69 

70 def box_for_point_dbu(x: float, y: float) -> kdb.Box: 

71 return kdb.Box(x, y, x + 20, y + 20) 

72 

73 for p in cell_data.ext_data.ports: 

74 port_cat = self.report.create_category(parent=ports_cat, name=f"{p.net} ({p.layer})") 

75 shapes = kdb.Shapes() 

76 shapes.insert(kdb.Box(p.x_bot / dbu_to_um / self.dbu, 

77 p.y_bot / dbu_to_um / self.dbu, 

78 p.x_top / dbu_to_um / self.dbu, 

79 p.y_top / dbu_to_um / self.dbu)) 

80 self.report.create_items(cell_id=rdb_cell.rdb_id(), category_id=port_cat.rdb_id(), 

81 trans=kdb.CplxTrans(mag=self.dbu), shapes=shapes) 

82 

83 for n in cell_data.ext_data.nodes: 

84 node_cat = self.report.create_category(parent=nodes_cat, name=f"{n.net} ({n.layer})") 

85 shapes = kdb.Shapes() 

86 shapes.insert(box_for_point_dbu(n.x_bot / dbu_to_um / self.dbu, 

87 n.y_bot / dbu_to_um / self.dbu)) 

88 self.report.create_items(cell_id=rdb_cell.rdb_id(), category_id=node_cat.rdb_id(), 

89 trans=kdb.CplxTrans(mag=self.dbu), shapes=shapes) 

90 

91 for d in cell_data.ext_data.devices: 

92 device_cat = self.report.create_category(parent=devices_cat, 

93 name=f"Type={d.device_type} Model={d.model}") 

94 shapes = kdb.Shapes() 

95 shapes.insert(kdb.Box(d.x_bot / dbu_to_um / self.dbu, 

96 d.y_bot / dbu_to_um / self.dbu, 

97 d.x_top / dbu_to_um / self.dbu, 

98 d.y_top / dbu_to_um / self.dbu)) 

99 self.report.create_items(cell_id=rdb_cell.rdb_id(), category_id=device_cat.rdb_id(), 

100 trans=kdb.CplxTrans(mag=self.dbu), shapes=shapes) 

101 

102 if cell_data.res_ext_data is not None: 

103 for n in cell_data.res_ext_data.rnodes: 

104 rnode_cat = self.report.create_category(parent=rnodes_cat, 

105 name=n.name) 

106 shapes = kdb.Shapes() 

107 shapes.insert(box_for_point_dbu(n.x_bot / dbu_to_um / self.dbu, 

108 n.y_bot / dbu_to_um / self.dbu)) 

109 self.report.create_items(cell_id=rdb_cell.rdb_id(), category_id=rnode_cat.rdb_id(), 

110 trans=kdb.CplxTrans(mag=self.dbu), shapes=shapes) 

111 

112 for idx, r in enumerate(cell_data.res_ext_data.resistors): 

113 res_cat = self.report.create_category(parent=resistors_cat, 

114 name=f"#{idx} {r.node1}↔︎{r.node2} = {r.value_ohm} Ω") 

115 shapes = kdb.Shapes() 

116 for n in cell_data.res_ext_data.rnodes_by_name(r.node1) + \ 

117 cell_data.res_ext_data.rnodes_by_name(r.node2): 

118 box = box_for_point_dbu(n.x_bot / dbu_to_um / self.dbu, 

119 n.y_bot / dbu_to_um / self.dbu) 

120 shapes.insert(box) 

121 self.report.create_items(cell_id=rdb_cell.rdb_id(), category_id=res_cat.rdb_id(), 

122 trans=kdb.CplxTrans(mag=self.dbu), shapes=shapes) 

123 

124 

125class ArgumentValidationError(Exception): 

126 pass 

127 

128 

129def _parse_args(arg_list: List[str] = None) -> argparse.Namespace: 

130 main_parser = argparse.ArgumentParser(description=f"{PROGRAM_NAME}: " 

131 f"Tool to create KLayout RDB for magic runs", 

132 add_help=False, 

133 formatter_class=RichHelpFormatter) 

134 

135 main_parser.add_argument("--magic_log_dir", "-m", 

136 dest="magic_log_dir_path", required=True, 

137 help="Input magic log directory path") 

138 

139 main_parser.add_argument("--out", "-o", 

140 dest="output_rdb_path", default=None, 

141 help="Magic log directory path (default is input directory / 'report.rdb.gz')") 

142 

143 if arg_list is None: 

144 arg_list = sys.argv[1:] 

145 args = main_parser.parse_args(arg_list) 

146 

147 if not os.path.isdir(args.magic_log_dir_path): 

148 raise ArgumentValidationError(f"Intput magic log directory does not exist at '{args.magic_log_dir_path}'") 

149 

150 if args.output_rdb_path is None: 

151 os.path.join(args.magic_log_dir_path, 'report.rdb.gz') 

152 

153 return args 

154 

155 

156def main(): 

157 args = _parse_args() 

158 report = rdb.ReportDatabase('') 

159 

160 magic_pex_run = parse_magic_pex_run(Path(args.magic_log_dir_path)) 

161 

162 c = MagicLogAnalyzer(magic_pex_run=magic_pex_run, 

163 report=report, 

164 dbu=1e-3) 

165 c.analyze() 

166 report.save(args.output_rdb_path) 

167 

168 

169if __name__ == "__main__": 

170 main()