File size: 5,672 Bytes
784ee2c | 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 | #!/usr/bin/env ruby
#
# Generates the KLayout layer map file from the Virtuoso Stream Layer Map File
# It's really here to map from the Virtuoso purpose name to KLayout's LEF
# purpose name
#
# Virtuoso Stream Layer Map File Format:
# layer_name purpose_name gds_layer gds_datatype
#
# KLayout Layer Map File Format:
# layer_name lef_purpose_name gds_layer gds_datatype
#
# Usage: KLayoutLayerMapGenerator.rb -i <input_file> -o <output_file>
# [-m <layer_name_mapper_ruby_file>]
#
# layer_name_mapper is the path to a file that implements LayerNameMapper for
# custom layer name mapping
#
# File needs to be located in ~/.klayout/ruby
#
require 'optparse'
#
# Class to generate the layer map from the Virtuoso Stream Layer Map file
#
class KLayoutLayerMapGenerator
#
# Structs used to store data
#
VirtuosoLayerInfo = Struct.new(:cds_lpp, :gds)
VirtuosoLayerPurposePair = Struct.new(:layer_name, :purpose_name)
GDSLayerDataType = Struct.new(:layer, :datatype)
#
# Initializer
#
# layer_map: Stores mapping from layer name to VirtuosoLayerInfo object
#
def initialize(layer_name_mapper_file)
@layer_map = {}
# load in layer_name_mapper dynamically
load layer_name_mapper_file
@layer_name_mapper = LayerNameMapper.new()
end
#
# Reads the Virtuoso Layer Map file
#
def read_virtuoso_layer_map_file(file_name)
fh = File.open(file_name, chomp: true)
if fh
read(fh)
fh.close
else
puts "Error: can't open " + file_name
end
end
#
# Reads the content from a stream
#
# For each layer in the layer mapping file, add an entry into layer_map.
# The key is the mapped layer name and the value is a list of
# VirtuosoLayerInfo objects. The value is a list since there can be multiple
# entries for the same mapped layer name in the Virtuoso map
#
def read(fh)
layer_re = /(\S+)\s+(\S+)\s+(\d+)\s+(\d+)([^#]*)\#\s*(\S+)?/
fh.each_line do | line |
if not line.match(/^#/)
result = line.match(layer_re)
if result
layer_name = result[1]
purpose_name = result[2]
gds_layer = result[3].to_i
gds_datatype = result[4].to_i
design_manual_layer_name = result[6]
key = map_layer_name(design_manual_layer_name, layer_name,
purpose_name)
cds_lpp = VirtuosoLayerPurposePair.new(layer_name, purpose_name)
gds = GDSLayerDataType.new(gds_layer, gds_datatype)
layer_info = VirtuosoLayerInfo.new(cds_lpp, gds)
if @layer_map[key]
@layer_map[key] << layer_info
else
@layer_map[key] = [layer_info]
end
else
if line != "\n"
puts "Skipping: " + line
end
end
end
end
end
#
# Maps layers to the desired name in the layer map
#
def map_layer_name(design_manual_layer_name, cds_layer_name, cds_purpose_name)
return @layer_name_mapper.map_layer_name(design_manual_layer_name, cds_layer_name, cds_purpose_name)
end
#
# Writes the layer map to a file
#
def write_layer_map_file(file_name)
out_fh = File.open(file_name, "w") do |out_fh|
write_layer_map(out_fh)
end
end
#
# Writes the layer map to a file handle
#
def write_layer_map(outfh)
layer_map = get_map()
layer_map.each { | layer_name, layer_list |
layer_list.each { | layer_info |
gds_info = layer_info.gds
outfh.printf("%s %d %d\n", layer_name, gds_info.layer,
gds_info.datatype)
}
}
end
#
# Accessor to return a hash sorted by the gds layer
#
def get_map
sorted_hash = @layer_map.sort_by {|key, value| value[0].gds.layer }
sorted_hash = Hash[sorted_hash]
return sorted_hash
end
#
# Standalone main driver
#
def KLayoutLayerMapGenerator.main
options = {"layer_name_mapper": "GenericLayerNameMapper.rb"}
OptionParser.new do |opts|
opts.banner = "Usage: KLayoutLayerMapGenerator.rb -i input_file -o output_file"
opts.on("-iINPUT_FILE", "--input_file=INPUT_FILE") do |input_file|
options[:input_file] = input_file
end
opts.on("-oOUTPUT_FILE", "--output_file=OUTPUT_FILE") do |output_file|
options[:output_file] = output_file
end
opts.on("-mLAYER_NAME_MAPPER", "--layer_name_mapper=LAYER_NAME_MAPPER") do |layer_name_mapper_ruby_file|
options[:layer_name_mapper_ruby_file] = layer_name_mapper_ruby_file
end
end.parse!
if options[:input_file] && options[:output_file]
rep = KLayoutLayerMapGenerator.new(options[:layer_name_mapper_ruby_file])
rep.read_virtuoso_layer_map_file(options[:input_file])
rep.write_layer_map_file(options[:output_file])
else
puts "Usage: KLayoutLayerMapGenerator.rb -i input_file -o output_file [-m layer_name_mapper]"
exit 1
end
end
end
#
# Only call the main driver if we're calling this as a script
#
if __FILE__ == $0
KLayoutLayerMapGenerator.main()
end
|