1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292 | ###############################################################################
# Copyright (c) 2003-2024 by Altair Engineering, Inc.
# All rights reserved.
#
# Altair Engineering, Inc. makes this software available as part of the Vision
# tool platform. As long as you are a licensee of the Vision tool platform
# you may make copies of the software and modify it to be used within the
# Vision tool platform, but you must include all of this notice on any copy.
# Redistribution without written permission to any third party, with or
# without modification, is not permitted.
# Altair Engineering, Inc. does not warrant that this software is error free
# or fit for any purpose. Altair Engineering, Inc. disclaims any liability for
# all claims, expenses, losses, damages and costs any user may incur as a
# result of using, copying or modifying the software.
# =============================================================================
# @userware
# Read Group Information
# @section
# Read Side Files and Annotate Data
# @description
# Read a text file that contains grouped instance information. All
# instances of a group are loaded into the Memory window and the Cone
# window.
# @files
# cust2/showInstGroups.tcl
# cust2/input_file.txt
# @example
# demo/spice/csim90/chip2.sp
# @cmdline
# -hspice @example[0]
# -userware @files[0]
# @tag
# zdb gui
###############################################################################
##
# After reading a text file which contains grouped instance information, this
# userware script opens a new Visualizer window for each group (The first
# group is displayed in the main Visualizer). All instances of a group are
# loaded into the Memory Window and the Cone Window. In the Cone Window the
# instances (if they refer to a module) are completed.
#
#
# Define labels for the main menu and the menu entry below the main menu.
#
set menuLabel "Userware"
set menuEntryLabel "Read Instance Group File"
# -----------------------------------------------------------------------------
# _readInstGroupFile - Show an Open File Dialog Window to load the Input File.
# -----------------------------------------------------------------------------
#
proc _readInstGroupFile {} {
set file [gui window fileDialog openFile "Browse Instance Group File" {}]
if {$file == "" } {
return
}
parseInputFile $file
}
# -----------------------------------------------------------------------------
# parseInputFile - Parse the input file and collect a list of instance paths.
# -----------------------------------------------------------------------------
#
proc parseInputFile {file} {
global Group
##
# Open the input file for reading.
#
set in [open $file r]
##
# Initialize the number of groups and the counter for elements
# inside a group.
#
set groupCount 0
set count 0
##
# Read the input file line by line.
#
while {![eof $in]} {
gets $in line
set line [string trim $line]
##
# Ignore empty lines.
#
if {[string length $line] == 0} {
continue
}
##
# If a line starts with #Path then increment the group count and
# reset the counter of elements in this group.
#
if {[string match "#Path*" $line]} {
incr groupCount
set count 0
continue
}
##
# If a line starts with # is a comment.
#
if {[string match "#*" $line]} {
continue
}
##
# Add this instance path to the corresponding group and increment
# the number of elements inside this group.
#
if {$groupCount > 0} {
set Group($groupCount:$count) $line
incr count
}
}
##
# Close the input file.
#
close $in
##
# Call the processPaths procedure with the number of groups found.
#
processPaths $groupCount
}
# -----------------------------------------------------------------------------
# processPaths - Loop over the list of instance paths and load the data to the
# Memory and Cone Window. Foreach group open a new Visualizer.
# -----------------------------------------------------------------------------
#
proc processPaths {groupCount} {
global Group
zprogress begin
zprogress push "Process Instance Paths" 1.0
##
# Loop over all groups.
#
for {set i 1} {$i <= $groupCount} {incr i} {
set n 0
##
# Show a progress bar with an interrupt button.
#
if {[zprogress update "" [expr {$i - 1}] $groupCount]} {
break
}
##
# The first group is shown in the main Visualizer.
# For all other groups a new Visualizer is opened.
# Show the Mem and Cone Window.
#
if {$i == 1} {
gui window show Mem
gui window show Cone
set cone "Cone"
set mem "Mem"
} else {
##
# Create a new Visualizer
#
set cone [gui window new Cone]
set tab [gui window split $cone left]
set mem [gui window new Mem -tabwindow $tab]
##
# Append the group number to the title
#
set top [winfo toplevel $tab]
set title [wm title $top]
append title " :: Group $i"
wm title $top $title
}
##
# Get the database
#
set db [gui database get]
##
# Clear the Memory and the Cone Window.
#
gui mem clear -window $mem
gui cone clear -window $cone
set oidList {}
##
# Loop over all elements ($n) in a group ($i).
#
while {[info exists Group($i:$n)]} {
##
# Split the instance path.
#
set tail {}
foreach elem [split $Group($i:$n) .] {
lappend tail $elem
}
##
# Loop over all top modules.
#
set valid 0
set oid {}
$db foreach top top {
##
# Build an inst OID and test if it is a valid OID.
# Break this loop at the first valid OID.
#
set oid [list inst [$db oid oname $top]]
set oid [concat $oid $tail]
if {![catch {$db oid create $oid}]} {
set valid 1
break
}
}
##
# If this was a valid OID append it to the OID list,
# else print an error message to the Console Window.
#
if {$valid} {
lappend oidList $oid
##
# Store this Object ID in the Memory Window.
#
gui mem append -window $mem [list $oid]
} else {
zmessage print ERR "$oid is not a valid Object ID."
}
incr n
}
##
# If at least one OID was valid then load all objects to the
# Cone Window, complete the contents of the modules and zoom
# to fullfit.
#
if {[llength $oidList] > 0} {
gui cone load $oidList -window $cone
doComplete $cone $oidList
update idletasks
gui cone zoom fullfit -window $cone
}
}
##
# End the progress bar.
#
zprogress pop
zprogress end
}
# -----------------------------------------------------------------------------
# doComplete - Complete module in Cone.
# cone: Cone window
# oidList: List of Object IDs to complete
# -----------------------------------------------------------------------------
#
proc doComplete {cone oidList} {
set db [gui database get]
set loadList {}
foreach oid $oidList {
if {([$db oid type $oid] != "inst") || (![$db isModule $oid])} {
zmessage print ERR "Complete: ignore [list $oid]"
}
set mod [$db moduleOf $oid]
foreach type {inst net netBus} {
$db foreach $type $mod o { lappend loadList $o }
}
}
gui cone append $loadList -window $cone
}
##
# Add userware submenu and create one new entry.
#
gui menu command [list $menuLabel $menuEntryLabel] {_readInstGroupFile}
|