TinyTapeout/tt-support-tools
1
0
Fork 0
mirror of https://github.com/TinyTapeout/tt-support-tools.git synced 2026-11-03 12:46:08 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
5fc71aee3be4e9bb869333132ed9f122d99a7272
tt-support-tools/precheck/tech-files/sky130A_mr.drc
T

1630 lines
52 KiB
Plaintext
Raw Blame History

# DRC for SKY130 according to :
# https://skywater-pdk.readthedocs.io/en/latest/rules/periphery.html
# https://skywater-pdk.readthedocs.io/en/latest/rules/layers.html
#
# Distributed under GNU GPLv3: https://www.gnu.org/licenses/
#
# History :
# 2022-6-22 : 2022.6.30_01.07 release
#
# 2023-6-14 : 2023.6.14_01.08 release
#
# 2024-2-11 : 2024.2.11_01.09 release
#
# 2024-5-26 : Update rectMCON_peri to use outside instead of not
# 2024-8-15 :
# * Avoid assigning to constant variables
# * Fix defaults for arguments when they are not passed in the CLI
#
# 2024-8-18 :
# * Add new rules:
# * `MR_lvtn.OVL.2`
# * `MR_tunm.CON.1`
# * `rdl.1`
# * `rdl.2`
# * `MR_thkox.CON.1`
# * `MR_rdl.CON.1`
# * `MR_li.WID.4`
# * `moduleCut.1`
# * Modify `licon` checks to account for ("non-bar" | exempt prec_resistor)
# * Rename `licon` checks
# 2024-9-1 :
# * Change the default of sram_exclude to false
##########################################################################################
release = "2024.2.11_01.09"
require "time"
require "logger"
exec_start_time = Time.now
logger = Logger.new(STDOUT)
logger.formatter =
proc do |severity, datetime, progname, msg|
"#{msg}
"
end
# optionnal for a batch launch : klayout -b -rd input=my_layout.gds -rd report=sky130_drc.txt -r drc_sky130.drc
source($input, $top_cell) if $input
if $report
report("SKY130 DRC runset", $report)
else
report(
"SKY130 DRC runset",
File.join(File.dirname(RBA::CellView.active.filename), "sky130_drc.txt")
)
end
if not defined? $feol
$feol = "false"
end
if not defined? $beol
$beol = "false"
end
if not defined? $offgrid
$offgrid = "false"
end
if not defined? $floating_met
$floating_met = "false"
end
if not defined? $sram_exclude
$sram_exclude = "false"
end
AL = true # do not change
CU = false # do not change
# choose betwen only one of AL or CU back-end flow here :
backend_flow = AL
# enable / disable rule groups
if $feol == "0" || $feol == "false"
FEOL = false
else
FEOL = true # front-end-of-line checks
end
if $beol == "0" || $beol == "false"
BEOL = false
else
BEOL = true # back-end-of-line checks
end
if $offgrid == "0" || $offgrid == "false"
OFFGRID = false
else
OFFGRID = true # manufacturing grid/angle checks
end
if $seal == "0" || $seal == "false"
SEAL = false
else
SEAL = true # SEAL RING checks
end
if $floating_met == "0" || $floating_met == "false"
FLOATING_MET = false
else
FLOATING_MET = true # back-end-of-line checks
end
if $sram_exclude == "0" || $sram_exclude == "false"
SRAM_EXCLUDE = false # back-end-of-line checks
else
SRAM_EXCLUDE = true
end
logger.info("Args:")
logger.info("\tsram_exclude: #{$sram_exclude}")
logger.info("\tfeol: #{$feol}")
logger.info("\tbeol: #{$beol}")
logger.info("\tfloating_met: #{$floating_met}")
logger.info("\toffgrid: #{$offgrid}")
logger.info("\tseal: #{$seal}")
# klayout setup
########################
# use a tile size of 1mm - not used in deep mode-
# tiles(1000.um)
# use a tile border of 10 micron:
# tile_borders(1.um)
#no_borders
# hierachical
deep
$thr ? threads($thr) : threads(4)
# if more inof is needed, set true
# verbose(true)
verbose(true)
# layers definitions
########################
# all except purpose (datatype) 5 -- label and 44 -- via
li_wildcard = "67/20"
li_res_wildcard = "67/13"
mcon_wildcard = "67/44"
m1_wildcard = "68/20"
via_wildcard = "68/44"
m2_wildcard = "69/20"
via2_wildcard = "69/44"
m3_wildcard = "70/20"
via3_wildcard = "70/44"
m4_wildcard = "71/20"
via4_wildcard = "71/44"
m5_wildcard = "72/20"
nsdm_wildcard = "93/44"
psdm_wildcard = "94/20"
nwell_wildcard = "64/20"
diff = input(65, 20)
tap = polygons(65, 44)
nwell = polygons(nwell_wildcard)
dnwell = polygons(64, 18)
pwbm = polygons(19, 44)
pwde = polygons(124, 20)
natfet = polygons(124, 21)
hvtr = polygons(18, 20)
hvtp = polygons(78, 44)
ldntm = polygons(11, 44)
hvi = polygons(75, 20)
tunm = polygons(80, 20)
lvtn = polygons(125, 44)
poly = polygons(66, 20)
hvntm = polygons(125, 20)
nsdm = polygons(nsdm_wildcard)
psdm = polygons(psdm_wildcard)
rpm = polygons(86, 20)
urpm = polygons(79, 20)
npc = polygons(95, 20)
licon = polygons(66, 44)
li = polygons(li_wildcard)
li_res = polygons(li_res_wildcard)
mcon = polygons(mcon_wildcard)
m1 = polygons(m1_wildcard)
via = polygons(via_wildcard)
m2 = polygons(m2_wildcard)
via2 = polygons(via2_wildcard)
m3 = polygons(m3_wildcard)
via3 = polygons(via3_wildcard)
m4 = polygons(m4_wildcard)
via4 = polygons(via4_wildcard)
m5 = polygons(m5_wildcard)
pad = polygons(76, 20)
nsm = polygons(61, 20)
capm = polygons(89, 44)
cap2m = polygons(97, 44)
rdl = polygons(74, 20)
vhvi = polygons(74, 21)
uhvi = polygons(74, 22)
npn = polygons(82, 20)
inductor = polygons(82, 24)
vpp = polygons(82, 64)
pnp = polygons(82, 44)
lvs_prune = polygons(84, 44)
ncm = polygons(92, 44)
padcenter = polygons(81, 20)
mf = polygons(76, 44)
areaid_sl = polygons(81, 1)
areaid_ce = polygons(81, 2)
areaid_fe = polygons(81, 3)
areaid_sc = polygons(81, 4)
areaid_sf = polygons(81, 6)
areaid_sw = polygons(81, 7)
areaid_sr = polygons(81, 8)
areaid_mt = polygons(81, 10)
areaid_dt = polygons(81, 11)
areaid_ft = polygons(81, 12)
areaid_ww = polygons(81, 13)
areaid_ld = polygons(81, 14)
areaid_ns = polygons(81, 15)
areaid_ij = polygons(81, 17)
areaid_zr = polygons(81, 18)
areaid_ed = polygons(81, 19)
areaid_de = polygons(81, 23)
areaid_rd = polygons(81, 24)
areaid_dn = polygons(81, 50)
areaid_cr = polygons(81, 51)
areaid_cd = polygons(81, 52)
areaid_st = polygons(81, 53)
areaid_op = polygons(81, 54)
areaid_en = polygons(81, 57)
areaid_en20 = polygons(81, 58)
areaid_le = polygons(81, 60)
areaid_hl = polygons(81, 63)
areaid_sd = polygons(81, 70)
areaid_po = polygons(81, 81)
areaid_it = polygons(81, 84)
areaid_et = polygons(81, 101)
areaid_lvt = polygons(81, 108)
areaid_re = polygons(81, 125)
areaid_ag = polygons(81, 79)
poly_rs = polygons(66, 13)
poly_fill = polygons(66, 99)
diff_rs = polygons(65, 13)
pwell_rs = polygons(64, 13)
li_rs = polygons(67, 13)
cfom = polygons(22, 20)
thkox = polygons(75, 21)
areaid_ce_merged = areaid_ce.merged
# Define a new custom function that selects polygons by their number of holes:
# It will return a new layer containing those polygons with min to max holes.
# max can be nil to omit the upper limit.
class DRC::DRCLayer
def with_holes(min, max)
new_data = RBA::Region.new
self.data.each do |p|
new_data.insert(p) if p.holes >= (min || 0) && (!max || p.holes <= max)
end
DRC::DRCLayer.new(@engine, new_data)
end
end
# DRC section
########################
log("DRC section")
if FEOL
log("FEOL section")
# dnwell
log("START: 64/18 (dnwell)")
dnwell.width(3.0, euclidian).output(
"dnwell.1",
"dnwell.1: min. dnwell width : 3.0um"
)
dnwell
.not(uhvi.or(vhvi))
.space(6.3, euclidian)
.output("dnwell.2", "dnwell.2 : min. dnwell spacing : 6.3um")
log("END: 64/18 (dnwell)")
not_sram = layout(source.cell_obj).select("-*sky130_sram_*kbyte_*")
not_sram_nsdm = not_sram.input(nsdm_wildcard)
not_sram_psdm = not_sram.input(psdm_wildcard)
not_sram_nwell = not_sram.input(nwell_wildcard)
# This is a hack, should be reverted
not_io =
layout(source.cell_obj).select(
"-*sky130_fd_io__gpiov2_amux",
"-*sky130_fd_io__simple_pad_and_busses"
)
not_io_nwell = not_io.input(nwell_wildcard)
# nwell
log("START: 64/20 (nwell)")
nwell.width(0.84, euclidian).output(
"nwell.1",
"nwell.1 : min. nwell width : 0.84um"
)
nwell.space(1.27, euclidian).output(
"nwell.2a",
"nwell.2a : min. nwell spacing (merged if less) : 1.27um"
)
nwell_interact = not_sram_nwell.and(not_io_nwell).merge
dnwell.enclosing(nwell_interact.holes, 1.03, euclidian).output(
"nwell.6",
"nwell.6 : min enclosure of nwellHole by dnwell : 1.03um"
)
hvmarker = hvi.or(rdl).or(uhvi).or(vhvi)
nwell
.interacting(nwell.and(hvmarker))
.not(hvmarker)
.output("nwell.9", "nwell.9 : HVnwell must be enclosed by hv marker")
log("END: 64/20 (nwell)")
# hvtp
log("START: 78/44 (hvtp)")
hvtp.width(0.38, euclidian).output(
"hvtp.1",
"hvtp.1 : min. hvtp width : 0.38um"
)
hvtp.space(0.38, euclidian).output(
"hvtp.2",
"hvtp.2 : min. hvtp spacing : 0.38um"
)
log("END: 78/44 (hvtp)")
# pwde
log("START: 124/20 (pwde)")
pwde.width(0.84, euclidian).output(
"pwde.1",
"pwde.1 : min. pwde width : 0.84um"
)
pwde
.and(uhvi.or(vhvi))
.space(1.27, euclidian)
.output("pwde.2", "pwde.2 : min. pwde inside v20 spacing : 1.27um")
log("END: 124/20 (pwde)")
# hvtr
log("START: 18/20 (htvr)")
hvtr.width(0.38, euclidian).output(
"hvtr.1",
"hvtr.1 : min. hvtr width : 0.38um"
)
hvtr.separation(hvtp, 0.38, euclidian).output(
"hvtr.2",
"hvtr.2 : min. hvtr spacing : 0.38um"
)
hvtr.and(hvtp).output("hvtr.2_a", "hvtr.2_a : hvtr must not overlap hvtp")
log("END: 18/20 (htvr)")
# lvtn
log("START: 25/44 (lvtn)")
lvtn.width(0.38, euclidian).output(
"lvtn.1a",
"lvtn.1a : min. lvtn width : 0.38um"
)
lvtn.space(0.38, euclidian).output(
"lvtn.2",
"lvtn.2 : min. lvtn spacing : 0.38um"
)
lvtn
.interacting(nwell)
.not_inside(nwell)
.edges
.and(nwell)
.output("MR_lvtn.OVL.2", "MR_lvtn.OVL.2 : lvtn must not straddle nwell")
log("END: 25/44 (lvtn)")
# ncm
log("START: 92/44 (ncm)")
ncm.width(0.38, euclidian).output("ncm.1", "ncm.1 : min. ncm width : 0.38um")
ncm.space(0.38, euclidian).output(
"ncm.2a",
"ncm.2a : min. ncm spacing : 0.38um"
)
log("END: 92/44 (ncm)")
# diff-tap
log("START: 65/20 (diff)")
difftap = diff.or(tap)
diff_width = diff.rectangles.width(0.15, euclidian).polygons
diff_cross_areaid_ce =
diff_width
.edges
.outside_part(areaid_ce)
.not(diff_width.outside(areaid_ce).edges)
diff_cross_areaid_ce.output(
"difftap.1",
"difftap.1 : min. diff width across areaid:ce : 0.15um"
)
diff
.outside(areaid_ce)
.width(0.15, euclidian)
.output(
"difftap.1_a",
"difftap.1_a : min. diff width in periphery : 0.15um"
)
diff
.inside(areaid_ce)
.width(0.14, euclidian)
.output(
"difftap.2",
"difftap.2 : min. diff width inside areadid:ce : 0.14um"
)
log("END: 65/20 (diff)")
log("START: 65/44 (tap)")
tap_width = tap.rectangles.width(0.15, euclidian).polygons
tap_cross_areaid_ce =
tap_width
.edges
.outside_part(areaid_ce)
.not(tap_width.outside(areaid_ce).edges)
tap_cross_areaid_ce.output(
"difftap.1_b",
"difftap.1_b : min. tap width across areaid:ce : 0.15um"
)
tap
.not(areaid_ce)
.width(0.15, euclidian)
.output("difftap.1_c", "difftap.1_c : min. tap width in periphery : 0.15um")
log("END: 65/44 (tap)")
difftap.space(0.27, euclidian).output(
"difftap.3",
"difftap.3 : min. difftap spacing : 0.27um"
)
# tunm
log("START: 80/20 (tunm)")
tunm.width(0.41, euclidian).output(
"tunm.1",
"tunm.1 : min. tunm width : 0.41um"
)
tunm.space(0.5, euclidian).output(
"tunm.2",
"tunm.2 : min. tunm spacing : 0.5um"
)
tunm.output(
"MR_tunm.CON.1",
"MR_tunm.CON.1 : use of layer tunm is prohibited"
)
log("END: 80/20 (tunm)")
# thkox
log("START: 80/20 (thkox)")
thkox_peri = thkox.not(areaid_ce)
thkox_peri.width(0.6, euclidian).output(
"thkox.1",
"thkox.1 : min. thkox width inside periphery : 0.6um"
)
thkox_peri.space(0.7, euclidian).output(
"thkox.2",
"thkox.2 : min. thkox spacing inside periphery : 0.7um"
)
thkox
.interacting(diff)
.not_inside(diff)
.edges
.and(diff)
.output("MR_thkox.CON.1", "MR_thkox.CON.1 : thkox must not straddle diff")
log("END: 80/20 (thkox)")
# poly
log("START: 66/20 (poly)")
poly.width(0.15, euclidian).output(
"poly.1a",
"poly.1a : min. poly width : 0.15um"
)
poly
.not(areaid_ce)
.space(0.21, euclidian)
.output("poly.2", "poly.2 : min. poly spacing : 0.21um")
core_poly_gap = poly.inside(areaid_ce).drc(width(projection) <= 0.15).polygons
poly
.interacting(core_poly_gap)
.isolated(0.16, projection)
.output("poly.3", "poly.3 : min. poly spacing inside areaid:core : 0.16um")
log("END: 66/20 (poly)")
# ldntm
log("START: 80/20 (ldntm)")
ldntm_core = ldntm.and(areaid_ce)
ldntm_core.width(0.7, euclidian).output(
"ldntm.1",
"ldntm.1 : min. ldntm width inside areaid:core : 0.7um"
)
ldntm_core.space(0.7, euclidian).output(
"ldntm.2",
"ldntm.2 : min. ldntm spacing inside areaid:core : 0.7um"
)
log("END: 80/20 (ldntm)")
# rpm
log("START: 86/20 (rpm)")
rpm.width(1.27, euclidian).output(
"rpm.1a",
"rpm.1a : min. rpm width : 1.27um"
)
rpm.space(0.84, euclidian).output(
"rpm.2",
"rpm.2 : min. rpm spacing : 0.84um"
)
log("END: 86/20 (rpm)")
# rdl
log("START: 74/20 (rdl)")
rdl.width(10.um, euclidian).output("rdl.1", "rdl.1 : min. rdl width : 10um")
rdl.space(10.um, euclidian).output("rdl.2", "rdl.2 : min. rdl spacing : 10um")
rdl.output("MR_rdl.CON.1", "MR_rdl.CON.1 : use of rdl layer is prohibited")
log("END: 74/20 (rdl)")
# urpm
log("START: 79/20 (urpm)")
urpm.width(1.27, euclidian).output(
"urpm.1a",
"urpm.1a : min. rpm width : 1.27um"
)
urpm.space(0.84, euclidian).output(
"urpm.2",
"urpm.2 : min. rpm spacing : 0.84um"
)
log("END: 79/20 (urpm)")
# npc
log("START: 95/20 (npc)")
npc.width(0.27, euclidian).output("npc.1", "npc.1 : min. npc width : 0.27um")
npc.space(0.27, euclidian).output(
"npc.2",
"npc.2 : min. npc spacing, should be manually merged if less than : 0.27um"
)
log("END: 95/20 (npc)")
# nsdm
log("START: 93/44 (nsdm)")
if SRAM_EXCLUDE
not_sram_nsdm
.not(areaid_ce)
.space(0.38, euclidian)
.output("nsdm.1", "nsdm.1 : min. nsdm spacing in periphery : 0.38um")
not_sram_nsdm
.outside(areaid_ce)
.width(0.38, euclidian)
.output("nsdm.2", "nsdm.2 : min. nsdm width in periphery : 0.38um")
not_sram_nsdm_width =
not_sram_nsdm
.width(0.38, euclidian)
.polygons
.interacting(areaid_ce_merged)
not_sram_nsdm_width.interacting(
not_sram_nsdm_width.edges.outside_part(areaid_ce_merged)
).output("nsdm.3", "nsdm.3 : min. diff width across areaid:ce : 0.38um")
nsdm_space =
not_sram_nsdm
.space(0.38, euclidian)
.polygons
.interacting(areaid_ce_merged)
nsdm_space.interacting(
nsdm_space.edges.outside_part(areaid_ce_merged)
).output("nsdm.4", "nsdm.4 : min. spacing across areaid:ce : 0.38um")
not_sram_nsdm
.inside(areaid_ce)
.width(0.29, euclidian)
.output("nsdm.5", "nsdm.5 : min. nsdm width in areaid:ce : 0.29um")
not_sram_nsdm
.inside(areaid_ce)
.space(0.29, euclidian)
.output("nsdm.6", "nsdm.6 : min. nsdm spacing in areaid:ce : 0.29um")
not_sram_nsdm
.inside(areaid_ce)
.space(0.38, projection)
.with_internal_angle(0)
.output(
"nsdm.6a",
"nsdm.6a : min. nsdm spacing on parallel edges in areaid:ce : 0.38um"
)
else
nsdm
.not(areaid_ce)
.space(0.38, euclidian)
.output("nsdm.1", "nsdm.1 : min. nsdm spacing in periphery : 0.38um")
nsdm
.outside(areaid_ce)
.width(0.38, euclidian)
.output("nsdm.2", "nsdm.2 : min. nsdm width in periphery : 0.38um")
nsdm_width =
nsdm.width(0.38, euclidian).polygons.interacting(areaid_ce_merged)
nsdm_width.interacting(
nsdm_width.edges.outside_part(areaid_ce_merged)
).output("nsdm.3", "nsdm.3 : min. diff width across areaid:ce : 0.38um")
nsdm_space =
nsdm.space(0.38, euclidian).polygons.interacting(areaid_ce_merged)
nsdm_space.interacting(
nsdm_space.edges.outside_part(areaid_ce_merged)
).output("nsdm.4", "nsdm.4 : min. spacing across areaid:ce : 0.38um")
nsdm
.inside(areaid_ce)
.width(0.29, euclidian)
.output("nsdm.5", "nsdm.5 : min. nsdm width in areaid:ce : 0.29um")
nsdm
.inside(areaid_ce)
.space(0.29, euclidian)
.output("nsdm.6", "nsdm.6 : min. nsdm spacing in areaid:ce : 0.29um")
nsdm
.inside(areaid_ce)
.space(0.38, projection)
.with_internal_angle(0)
.output(
"nsdm.6a",
"nsdm.6a : min. nsdm spacing on parallel edges in areaid:ce : 0.38um"
)
end # SRAM_EXCLUDE
log("END: 93/44 (nsdm)")
# psdm
log("START: 94/20 (psdm)")
if SRAM_EXCLUDE
not_sram_psdm
.not(areaid_ce)
.space(0.38, euclidian)
.output("psdm.1", "psdm.1 : min. psdm spacing in periphery : 0.38um")
not_sram_psdm
.outside(areaid_ce)
.width(0.38, euclidian)
.output("psdm.2", "psdm.2 : min. psdm width in periphery : 0.38um")
not_sram_psdm_width =
not_sram_psdm
.width(0.38, euclidian)
.polygons
.interacting(areaid_ce_merged)
not_sram_psdm_width.interacting(
not_sram_psdm_width.edges.outside_part(areaid_ce_merged)
).output("psdm.3", "psdm.3 : min. diff width across areaid:ce : 0.38um")
psdm_space =
not_sram_psdm
.space(0.38, euclidian)
.polygons
.interacting(areaid_ce_merged)
psdm_space.interacting(
psdm_space.edges.outside_part(areaid_ce_merged)
).output("psdm.4", "psdm.4 : min. spacing across areaid:ce : 0.38um")
not_sram_psdm
.inside(areaid_ce)
.width(0.29, euclidian)
.output("psdm.5", "psdm.5 : min. psdm width in areaid:ce : 0.29um")
not_sram_psdm
.inside(areaid_ce)
.space(0.29, euclidian)
.output("psdm.6", "psdm.6 : min. psdm spacing in areaid:ce : 0.29um")
not_sram_psdm
.inside(areaid_ce)
.space(0.38, projection)
.with_internal_angle(0)
.output(
"psdm.6a",
"psdm.6a : min. psdm spacing on parallel edges in areaid:ce : 0.38um"
)
not_sram_psdm
.and(not_sram_nsdm)
.and(diff)
.output(
"nsdm_psdm_overlap",
"nsdm_psdm_overlap : nsdm overlaps psdm over active"
)
else
psdm
.not(areaid_ce)
.space(0.38, euclidian)
.output("psdm.1", "psdm.1 : min. psdm spacing in periphery : 0.38um")
psdm
.outside(areaid_ce)
.width(0.38, euclidian)
.output("psdm.2", "psdm.2 : min. psdm width in periphery : 0.38um")
psdm_width =
psdm.width(0.38, euclidian).polygons.interacting(areaid_ce_merged)
psdm_width.interacting(
psdm_width.edges.outside_part(areaid_ce_merged)
).output("psdm.3", "psdm.3 : min. diff width across areaid:ce : 0.38um")
psdm_space =
psdm.space(0.38, euclidian).polygons.interacting(areaid_ce_merged)
psdm_space.interacting(
psdm_space.edges.outside_part(areaid_ce_merged)
).output("psdm.4", "psdm.4 : min. spacing across areaid:ce : 0.38um")
psdm
.inside(areaid_ce)
.width(0.29, euclidian)
.output("psdm.5", "psdm.5 : min. psdm width in areaid:ce : 0.29um")
psdm
.inside(areaid_ce)
.space(0.29, euclidian)
.output("psdm.6", "psdm.6 : min. psdm spacing in areaid:ce : 0.29um")
psdm
.inside(areaid_ce)
.space(0.38, projection)
.with_internal_angle(0)
.output(
"psdm.6a",
"psdm.6a : min. psdm spacing on parallel edges in areaid:ce : 0.38um"
)
psdm
.and(nsdm)
.and(diff)
.output(
"nsdm_psdm_overlap",
"nsdm_psdm_overlap : nsdm overlaps psdm over active"
)
end # SRAM_EXCLUDE
log("END: 94/20 (psdm)")
# licon
log("START: 66/44 (licon)")
polyi = poly_fill.and(poly)
poly_licon = (polyi.and(licon)).and(areaid_ce)
licon_peri = licon.outside(areaid_ce)
if SEAL
ringLICON = licon.drc(with_holes > 0)
rectLICON = licon.not(ringLICON)
else
rectLICON = licon
end
rectLICON.non_rectangles.output(
"licon.1_c",
"licon.1_c : licon should be rectangle"
)
prec_resistor = (rpm | urpm) & psdm & (poly.interacting(poly_rs))
licon_peri.not(prec_resistor).space(0.17, euclidian).output(
"MR_licon.SP.1",
"MR_licon.SP.1: min. licon spacing in periphery : 0.17um"
)
licon_not_prec_resistor = licon.not(prec_resistor)
licon_not_prec_resistor.drc(length != 0.17).output(
"licon.1",
"licon.1: min/max. licon length : 0.17um"
)
licon_peri
.and(difftap)
.separation(npc, 0.09, euclidian)
.output(
"licon.13",
"licon.13: min. licon on diff spacing to npc in periphery : 0.09um"
)
licon_peri
.and(difftap)
.and(npc)
.output(
"licon.13_a",
"licon.13_a: licon on diff in periphery can't overlap npc"
)
licon
.and(poly)
.and(difftap)
.output(
"licon.17",
"licon.17 : Licons may not overlap both poly and (diff or tap)"
)
xfom = difftap.not(poly)
licon1ToXfom = licon.interacting(licon.and(xfom))
polyLicon1 =
(licon.not(licon1ToXfom)).interacting((licon.not(licon1ToXfom)).and(poly))
polyLicon1_CORE = polyLicon1.and(areaid_ce)
npc.enclosing(polyLicon1_CORE, 0.045, euclidian).output(
"licon.6",
"licon.6 : npc min enclosure of poly_licon inside areaid:core : 0.045um"
)
polyLicon1_CORE.not(npc).output(
"licon.6",
"licon.6 : npc min enclosure of poly_licon inside areaid:core : 0.045um"
)
log("END: 66/44 (licon)")
#nsm
log("START: 61/20 (nsm)")
nsm.space(4.0, euclidian).output("nsm.1", "nsm.1 : nsm min. spacing : 4.0um")
nsm.width(3.0, euclidian).output("nsm.2", "nsm.2 : nsm min. width : 3.0um")
log("END: 61/20 (nsm)")
# CAPM
log("START: 89/44 (capm)")
capm.width(1.0, euclidian).output(
"capm.1",
"capm.1 : min. capm width : 1.0um"
)
capm.space(0.84, euclidian).output(
"capm.2a",
"capm.2a : min. capm spacing : 0.84um"
)
m3_bot_plate = ((capm.and(m3)).sized(0.14))
m3_bot_plate
.isolated(1.2, euclidian)
.polygons
.not(m3)
.output("capm.2b", "capm.2b : min. spacing between met3_bot_plate : 1.2um")
(m3.not_interacting(m3_bot_plate)).separation(
m3_bot_plate,
1.2,
euclidian
).output(
"capm.2b_a",
"capm.2b_a : min. spacing between met3_bot_plate and met3 : 1.2um"
)
# capm.and(m3).enclosing(m3, 0.14, euclidian).output("capm.3", "capm.3 : min. capm and m3 enclosure of m3 : 0.14um")
m3.enclosing(capm, 0.14, euclidian).output(
"capm.3",
"capm.3 : min. m3 enclosure of capm : 0.14um"
)
capm.enclosing(via3, 0.14, euclidian).output(
"capm.4",
"capm.4 : min. capm enclosure of via3 : 0.14um"
)
capm.separation(via3, 0.14, euclidian).output(
"capm.5",
"capm.5 : min. capm spacing to via3 : 0.14um"
)
(m3.not_interacting(capm)).separation(capm, 0.5, euclidian).output(
"capm.11",
"capm.11 : Min spacing of capm and met3 not overlapping capm : 0.5um"
)
log("END: 89/44 (capm)")
# CAP2M
log("START: 97/44 (cap2m)")
cap2m.width(1.0, euclidian).output(
"cap2m.1",
"cap2m.1 : min. cap2m width : 1.0um"
)
cap2m.space(0.84, euclidian).output(
"cap2m.2a",
"cap2m.2a : min. cap2m spacing : 0.84um"
)
m4
.interacting(cap2m)
.isolated(1.2, euclidian)
.output("cap2m.2b", "cap2m.2b : min. cap2m spacing : 1.2um")
(m4.interacting(cap2m)).isolated(1.2, euclidian).output(
"cap2m.2b_a",
"cap2m.2b_a : min. spacing of m4_bot_plate : 1.2um"
)
cap2m
.and(m4)
.enclosing(m4, 0.14, euclidian)
.output("cap2m.3", "cap2m.3 : min. m4 enclosure of cap2m : 0.14um")
m4.enclosing(cap2m, 0.14, euclidian).output(
"cap2m.3_a",
"cap2m.3_a : min. m4 enclosure of cap2m : 0.14um"
)
cap2m.enclosing(via4, 0.2, euclidian).output(
"cap2m.4",
"cap2m.4 : min. cap2m enclosure of via4 : 0.2um"
)
cap2m.separation(via4, 0.2, euclidian).output(
"cap2m.5",
"cap2m.5 : min. cap2m spacing to via4 : 0.2um"
)
(m4.not_interacting(cap2m)).separation(cap2m, 0.5, euclidian).output(
"cap2m.11",
"cap2m.11 : Min spacing of cap2m and met4 not overlapping cap2m : 0.5um"
)
log("END: 97/44 (cap2m)")
end #FEOL
if BEOL
log("BEOL section")
# li
log("START: 67/20 (li)")
li_outside_or_touching_areaidce =
(li.outside(areaid_ce)).or(
li.interacting(areaid_ce).not(li.inside(areaid_ce))
)
li_outside_or_touching_areaidce.width(0.17, euclidian).output(
"li.1",
"li.1 : min. li width outside or crossing areaid:ce : 0.17um"
)
li_outside_or_touching_areaidce.space(0.17, euclidian).output(
"li.3",
"li.3 : min. li spacing outside or crossing areaid:ce : 0.17um"
)
licon_peri = licon.not(areaid_ce)
li_edges_with_less_enclosure =
li.enclosing(licon_peri, 0.08, projection).second_edges
error_corners = li_edges_with_less_enclosure.width(angle_limit(100.0), 1.dbu)
li_interact = licon_peri.interacting(error_corners.polygons(1.dbu))
li_interact.output(
"li.5",
"li.5 : min. li enclosure of licon of 2 adjacent edges : 0.08um"
)
linotace = li.not(li.interacting(areaid_ce))
linotace.with_area(nil, 0.0561).output(
"li.6",
"li.6 : min. li area : 0.0561um²"
)
li_core = li.and(areaid_ce)
li_core.space(0.14, euclidian).output(
"li.7",
"li.7 : min. li core spacing : 0.14um"
)
li_core.width(0.14, euclidian).output(
"li.8",
"li.8 : min. li core width : 0.14um"
)
log("END: 67/20 (li)")
# li res
log("START: 67/13 (li_res)")
li_res.width(0.29, euclidian).output(
"MR_li.WID.4",
"MR_li.WID.4 : li:res minimum width : 0.29um"
)
log("END: 67/13 (li_res)")
# ct
log("START: 67/44 (mcon)")
mconnotace = mcon.not(areaid_ce)
if SEAL
ringMCON = mcon.drc(with_holes > 0)
rectMCON = mcon.not(ringMCON)
else
rectMCON = mcon
end
rectMCON_peri = rectMCON.outside(areaid_ce)
rectMCON.non_rectangles.output(
"ct.1",
"ct.1: non-ring mcon should be rectangular"
)
# rectMCON_peri.edges.without_length(0.17).output("ct.1_a/b", "ct.1_a/b : minimum/maximum width of mcon : 0.17um")
rectMCON_peri.drc(width < 0.17).output(
"ct.1_a",
"ct.1_a : minimum width of mcon : 0.17um"
)
rectMCON_peri.drc(length > 0.17).output(
"ct.1_b",
"ct.1_b : maximum length of mcon : 0.17um"
)
mcon.space(0.19, euclidian).output(
"ct.2",
"ct.2 : min. mcon spacing : 0.19um"
)
if SEAL
ringMCON.width(0.17, euclidian).output(
"ct.3",
"ct.3 : min. width of ring-shaped mcon : 0.17um"
)
ringMCON.drc(width >= 0.175).output(
"ct.3_a",
"ct.3_a : max. width of ring-shaped mcon : 0.175um"
)
ringMCON.not(areaid_sl).output(
"ct.3_b",
"ct.3_b: ring-shaped mcon must be enclosed by areaid_sl"
)
end
mconnotace.not(li).output("ct.4", "ct.4 : mcon should covered by li")
log("END: 67/44 (mcon)")
# m1
log("START: 68/20 (m1)")
m1.width(0.14, euclidian).output("m1.1", "m1.1 : min. m1 width : 0.14um")
huge_m1 = m1.sized(-1.5).sized(1.5).snap(0.005) & m1
non_huge_m1 = m1.edges - huge_m1
huge_m1 = huge_m1.edges.outside_part(m1.merged)
non_huge_m1.space(0.14, euclidian).output(
"m1.2",
"m1.2 : min. m1 spacing : 0.14um"
)
(
huge_m1.separation(non_huge_m1, 0.28, euclidian) +
huge_m1.space(0.28, euclidian)
).output("m1.3ab", "m1.3ab : min. 3um.m1 spacing m1 : 0.28um")
#not_in_cell6 = layout(source.cell_obj).select("-s8cell_ee_plus_sseln_a", "-s8cell_ee_plus_sseln_b", "-s8cell_ee_plus_sselp_a", "-s8cell_ee_plus_sselp_b", "-s8fpls_pl8", "-s8fs_cmux4_fm")
not_in_cell6 =
layout(source.cell_obj).select(
"-s8cell_ee_plus_sseln_a",
"-s8cell_ee_plus_sseln_b",
"-s8cell_ee_plus_sselp_a",
"-s8cell_ee_plus_sselp_b",
"-s8fs_cmux4_fm"
)
not_in_cell6_m1 = not_in_cell6.input(m1_wildcard)
not_in_cell6_m1.enclosing(mconnotace, 0.03, euclidian).output(
"791_m1.4",
"791_m1.4 : min. m1 enclosure of mcon : 0.03um"
)
mconnotace.not(m1).output(
"m1.4",
"m1.4 : mcon periphery must be enclosed by m1"
)
in_cell6 =
layout(source.cell_obj).select(
"-*",
"+s8cell_ee_plus_sseln_a",
"+s8cell_ee_plus_sseln_b",
"+s8cell_ee_plus_sselp_a",
"+s8cell_ee_plus_sselp_b",
"+s8fpls_pl8",
"+s8fs_cmux4_fm"
)
in_cell6_m1 = in_cell6.input(m1_wildcard)
in_cell6_m1.enclosing(mcon, 0.005, euclidian).output(
"m1.4a",
"m1.4a : min. m1 enclosure of mcon for specific cells : 0.005um"
)
in_cell6_m1.not(m1).output(
"m1.4a_a",
"m1.4a_a : mcon periph must be enclosed by met1 for specific cells"
)
m1.with_area(0..0.083).output("m1.6", "m1.6 : min. m1 area : 0.083um²")
m1
.holes
.with_area(0..0.14)
.output("m1.7", "m1.7 : min. m1 with holes area : 0.14um²")
if FLOATING_MET
m1.not_interacting(via.or(mcon)).output(
"m1.x",
"floating met1, must interact with via1"
)
end
if backend_flow = AL
#Could flag false positive, fix would be to add .rectangles for m1
mconnotace_edges_with_less_enclosure_m1 =
m1.enclosing(mconnotace, 0.06, projection).second_edges
error_corners_m1 =
mconnotace_edges_with_less_enclosure_m1.width(angle_limit(100.0), 1.dbu)
mconnotace_interact_m1 =
mconnotace.interacting(error_corners_m1.polygons(1.dbu))
mconnotace_interact_m1.output(
"m1.5",
"m1.5 : min. m1 enclosure of mcon of 2 adjacent edges : 0.06um"
)
end
log("END: 68/20 (m1)")
# via
log("START: 68/44 (via)")
if backend_flow = AL
if SEAL
ringVIA = via.drc(with_holes > 0)
rectVIA = via.not(ringVIA)
else
rectVIA = via
end
via_not_mt = rectVIA.not(areaid_mt)
via_not_mt.non_rectangles.output(
"via.1a",
"via.1a : via outside of moduleCut should be rectangular"
)
via_not_mt.width(0.15, euclidian).output(
"via.1a_a",
"via.1a_a : min. width of via outside of moduleCut : 0.15um"
)
# via_not_mt.edges.without_length(nil, 0.15 + 1.dbu).output("via.1a_b", "via.1a_b : maximum length of via : 0.15um")
via_not_mt.drc(length > 0.15).output(
"via.1a_b",
"via.1a_b : maximum length of via : 0.15um"
)
via.space(0.17, euclidian).output(
"via.2",
"via.2 : min. via spacing : 0.17um"
)
if SEAL
ringVIA.width(0.2, euclidian).output(
"via.3",
"via.3 : min. width of ring-shaped via : 0.2um"
)
ringVIA.drc(width >= 0.205).output(
"via.3_a",
"via.3_a : max. width of ring-shaped via : 0.205um"
)
ringVIA.not(areaid_sl).output(
"via.3_b",
"via.3_b: ring-shaped via must be enclosed by areaid_sl"
)
end
m1
.edges
.enclosing(rectVIA.drc(width == 0.15), 0.055, euclidian)
.output("via.4a", "via.4a : min. m1 enclosure of 0.15um via : 0.055um")
rectVIA
.squares
.drc(width == 0.15)
.not(m1)
.output("via.4a_a", "via.4a_a : 0.15um via must be enclosed by met1")
via1_edges_with_less_enclosure_m1 =
m1
.edges
.enclosing(rectVIA.drc(width == 0.15), 0.085, projection)
.second_edges
error_corners_via1 =
via1_edges_with_less_enclosure_m1.width(angle_limit(100.0), 1.dbu)
via2_interact = via.interacting(error_corners_via1.polygons(1.dbu))
via2_interact.output(
"via.5a",
"via.5a : min. m1 enclosure of 0.15um via of 2 adjacent edges : 0.085um"
)
end
log("END: 68/44 (via)")
# m2
log("START: 69/20 (m2)")
via_inside_periphery = via.and(areaid_ce)
m2.width(0.14, euclidian).output("m2.1", "m2.1 : min. m2 width : 0.14um")
huge_m2 = m2.sized(-1.5).sized(1.5).snap(0.005) & m2
non_huge_m2 = m2.edges - huge_m2
huge_m2 = huge_m2.edges.outside_part(m2.merged)
via_outside_periphery = via.not(areaid_ce)
non_huge_m2.space(0.14, euclidian).output(
"m2.2",
"m2.2 : min. m2 spacing : 0.14um"
)
(
huge_m2.separation(non_huge_m2, 0.28, euclidian) +
huge_m2.space(0.28, euclidian)
).output("m2.3ab", "m2.3ab : min. 3um.m2 spacing m2 : 0.28um")
m2.with_area(0..0.0676).output("m2.6", "m2.6 : min. m2 area : 0.0676um²")
m2
.holes
.with_area(0..0.14)
.output("m2.7", "m2.7 : min. m2 holes area : 0.14um²")
if FLOATING_MET
m2.not_interacting(via.or(via2)).output(
"m2.x",
"floating met2, must interact with via1 or via2"
)
end
if backend_flow = AL
m2.enclosing(via_outside_periphery, 0.055, euclidian).output(
"m2.4",
"m2.4 : min. m2 enclosure of via : 0.055um"
)
via_outside_periphery.not(m2).output(
"m2.4_a",
"m2.4_a : via in periphery must be enclosed by met2"
)
m2.enclosing(via_inside_periphery, 0.045, euclidian).output(
"m2.4_b",
"m2.4_B : min. m2 enclosure of via inside areaid:core : 0.045um"
)
via_edges_with_less_enclosure_m2 =
m2.enclosing(via_outside_periphery, 0.085, projection).second_edges
error_corners =
via_edges_with_less_enclosure_m2.width(angle_limit(100.0), 1.dbu)
via_interact = via.interacting(error_corners.polygons(1.dbu))
via_interact.output(
"m2.5",
"m2.5 : min. m2 enclosure of via of 2 adjacent edges : 0.085um"
)
end
log("END: 69/20 (m2)")
# via2
log("START: 69/44 (via2)")
if backend_flow = AL
if SEAL
ringVIA2 = via2.drc(with_holes > 0)
rectVIA2 = via2.not(ringVIA2)
else
rectVIA2 = via2
end
via2_not_mt = rectVIA2.not(areaid_mt)
via2_not_mt.non_rectangles.output(
"via2.1a",
"via2.1a : via2 outside of moduleCut should be rectangular"
)
via2_not_mt.width(0.2, euclidian).output(
"via2.1a_a",
"via2.1a_a : min. width of via2 outside of moduleCut : 0.2um"
)
via2_not_mt
.edges
.without_length(nil, 0.2 + 1.dbu)
.output("via2.1a_b", "via2.1a_b : maximum length of via2 : 0.2um")
via2.space(0.2, euclidian).output(
"via2.2",
"via2.2 : min. via2 spacing : 0.2um"
)
if SEAL
ringVIA2.width(0.2, euclidian).output(
"via2.3",
"via2.3 : min. width of ring-shaped via2 : 0.2um"
)
ringVIA2.drc(width >= 0.205).output(
"via2.3_a",
"via2.3_a : max. width of ring-shaped via2 : 0.205um"
)
ringVIA2.not(areaid_sl).output(
"via2.3_b",
"via2.3_b: ring-shaped via2 must be enclosed by areaid_sl"
)
end
m2.enclosing(via2, 0.04, euclidian).output(
"via2.4",
"via2.4 : min. m2 enclosure of via2 : 0.04um"
)
via2.not(m2).output("via2.4_a", "via2.4_a : via must be enclosed by met2")
via2_edges_with_less_enclosure =
m2.enclosing(via2, 0.085, projection).second_edges
error_corners =
via2_edges_with_less_enclosure.width(angle_limit(100.0), 1.dbu)
via2_interact = via2.interacting(error_corners.polygons(1.dbu))
via2_interact.output(
"via2.5",
"via2.5 : min. m3 enclosure of via2 of 2 adjacent edges : 0.085um"
)
end
log("END: 69/44 (via2)")
# m3
log("START: 70/20 (m3)")
m3.width(0.3, euclidian).output("m3.1", "m3.1 : min. m3 width : 0.3um")
huge_m3 = m3.sized(-1.5).sized(1.5).snap(0.005) & m3
non_huge_m3 = m3.edges - huge_m3
huge_m3 = huge_m3.edges.outside_part(m3.merged)
non_huge_m3.space(0.3, euclidian).output(
"m3.2",
"m3.2 : min. m3 spacing : 0.3um"
)
(
huge_m3.separation(non_huge_m3, 0.4, euclidian) +
huge_m3.space(0.4, euclidian)
).output("m3.3cd", "m3.3cd : min. 3um.m3 spacing m3 : 0.4um")
if FLOATING_MET
m3.not_interacting(via2.or(via3)).output(
"m3.x",
"floating met3, must interact with via2 or via3"
)
end
if backend_flow = AL
m3.enclosing(via2, 0.065, euclidian).output(
"m3.4",
"m3.4 : min. m3 enclosure of via2 : 0.065um"
)
via2.not(m3).output("m3.4_a", "m3.4_a : via2 must be enclosed by met3")
end
m3.with_area(0..0.240).output("m3.6", "m3.6 : min. m3 area : 0.240um²")
m3
.holes
.with_area(0..0.2)
.output("m3.7", "m3.7 : min. m3 holes area : 0.2um²")
log("END: 70/20 (m3)")
# via3
log("START: 70/44 (via3)")
if backend_flow = AL
if SEAL
ringVIA3 = via3.drc(with_holes > 0)
rectVIA3 = via3.not(ringVIA3)
else
rectVIA3 = via3
end
via3_not_mt = rectVIA3.not(areaid_mt)
via3_not_mt.non_rectangles.output(
"via3.1",
"via3.1 : via3 outside of moduleCut should be rectangular"
)
via3_not_mt.width(0.2, euclidian).output(
"via3.1_a",
"via3.1_a : min. width of via3 outside of moduleCut : 0.2um"
)
via3_not_mt
.edges
.without_length(nil, 0.2 + 1.dbu)
.output("via3.1_b", "via3.1_b : maximum length of via3 : 0.2um")
via3.space(0.2, euclidian).output(
"via3.2",
"via3.2 : min. via3 spacing : 0.2um"
)
m3.enclosing(via3, 0.06, euclidian).output(
"via3.4",
"via3.4 : min. m3 enclosure of via3 : 0.06um"
)
rectVIA3.not(m3).output(
"via3.4_a",
"via3.4_a : non-ring via3 must be enclosed by met3"
)
via_edges_with_less_enclosure =
m3.enclosing(via3, 0.09, projection).second_edges
error_corners =
via_edges_with_less_enclosure.width(angle_limit(100.0), 1.dbu)
via3_interact = via3.interacting(error_corners.polygons(1.dbu))
via3_interact.output(
"via3.5",
"via3.5 : min. m3 enclosure of via3 of 2 adjacent edges : 0.09um"
)
end
log("END: 70/44 (via3)")
# m4
log("START: 71/20 (m4)")
m4.width(0.3, euclidian).output("m4.1", "m4.1 : min. m4 width : 0.3um")
huge_m4 = m4.sized(-1.5).sized(1.5).snap(0.005) & m4
non_huge_m4 = m4.edges - huge_m4
huge_m4 = huge_m4.edges.outside_part(m4.merged)
non_huge_m4.space(0.3, euclidian).output(
"m4.2",
"m4.2 : min. m4 spacing : 0.3um"
)
m4.with_area(0..0.240).output("m4.4a", "m4.4a : min. m4 area : 0.240um²")
(
huge_m4.separation(non_huge_m4, 0.4, euclidian) +
huge_m4.space(0.4, euclidian)
).output("m4.5ab", "m4.5ab : min. 3um.m4 spacing m4 : 0.4um")
if FLOATING_MET
m4.not_interacting(via3.or(via4)).output(
"m4.x",
"floating met3, must interact with via3 or via4"
)
end
if backend_flow = AL
m4.enclosing(via3, 0.065, euclidian).output(
"m4.3",
"m4.3 : min. m4 enclosure of via3 : 0.065um"
)
via3.not(m4).output("m4.3_a", "m4.3_a : via3 must be enclosed by met4")
end
m4
.holes
.with_area(0..0.2)
.output("m4.7", "m4.7 : min. m4 holes area : 0.2um²")
log("END: 71/20 (m4)")
# via4
log("START: 71/44 (via4)")
if SEAL
ringVIA4 = via4.drc(with_holes > 0)
rectVIA4 = via4.not(ringVIA4)
else
rectVIA4 = via4
end
via4_not_mt = rectVIA4.not(areaid_mt)
via4_not_mt.non_rectangles.output(
"via4.1",
"via4.1 : via4 outside of moduleCut should be rectangular"
)
rectVIA4.width(0.8, euclidian).output(
"via4.1_a",
"via4.1_a : min. width of via4 outside of moduleCut : 0.8um"
)
rectVIA4.drc(length > 0.8).output(
"via4.1_b",
"via4.1_b : maximum length of via4 : 0.8um"
)
via4
.space(0.8, euclidian)
.polygons
.output("via4.2", "via4.2 : min. via4 spacing : 0.8um")
if SEAL
ringVIA4.width(0.8, euclidian).output(
"via4.3",
"via4.3 : min. width of ring-shaped via4 : 0.8um"
)
ringVIA4.drc(width >= 0.805).output(
"via4.3_a",
"via4.3_a : max. width of ring-shaped via4 : 0.805um"
)
ringVIA4.not(areaid_sl).output(
"via4.3_b",
"via4.3_b: ring-shaped via4 must be enclosed by areaid_sl"
)
end
m4.enclosing(via4, 0.19, euclidian).output(
"via4.4",
"via4.4 : min. m4 enclosure of via4 : 0.19um"
)
rectVIA4.not(m4).output("via4.4_a", "via4.4_a : m4 must enclose all via4")
log("END: 71/44 (via4)")
# m5
log("START: 72/20 (m5)")
m5.width(1.6, euclidian).output("m5.1", "m5.1 : min. m5 width : 1.6um")
m5.space(1.6, euclidian).output("m5.2", "m5.2 : min. m5 spacing : 1.6um")
m5.enclosing(via4, 0.31, euclidian).output(
"m5.3",
"m5.3 : min. m5 enclosure of via4 : 0.31um"
)
via4.not(m5).output("m5.3_a", "m5.3_a : via must be enclosed by m5")
if FLOATING_MET
m5.not_interacting(via4).output(
"m5.x",
"floating met5, must interact with via4"
)
end
m5.with_area(0..4.0).output("m5.4", "m5.4 : min. m5 area : 4.0um²")
m5
.holes
.with_area(0..0.14)
.output("m5.7", "m5.7 : min. m5 holes area : 0.14um²")
log("END: 72/20 (m5)")
# pad
log("START: 76/20 (pad)")
pad.space(1.27, euclidian).output(
"pad.2",
"pad.2 : min. pad spacing : 1.27um"
)
log("END: 76/20 (pad)")
log("START: 81/10 (moduleCut)")
areaid_mt.output(
"moduleCut.1",
"moduleCut.1 : moduleCut layer is for SkyWater use only"
)
log("END: 81/10 (moduleCut)")
#areaid_mt = polygons(81, 10)
end #BEOL
if FEOL
log("FEOL section")
# hvi
log("START: 75/20 (hvi)")
hvi_peri = hvi.not(areaid_ce)
hvi_peri.width(0.6, euclidian).output(
"hvi.1",
"hvi.1 : min. hvi width : 0.6um"
)
hvi_peri.space(0.7, euclidian).output(
"hvi.2a",
"hvi.2a : min. hvi spacing : 0.7um"
)
log("END: 75/20 (hvi)")
# hvntm
log("START: 125/20 (hvntm)")
hvntm_peri = hvntm.not(areaid_ce)
hvntm_peri.width(0.7, euclidian).output(
"hvntm.1",
"hvntm.1 : min. hvntm width : 0.7um"
)
hvntm_peri.space(0.7, euclidian).output(
"hvntm.2",
"hvntm.2 : min. hvntm spacing : 0.7um"
)
log("END: 125/20 (hvntm)")
end #FEOL
if OFFGRID
log("OFFGRID-ANGLES section")
dnwell.ongrid(0.005).output(
"dnwell_OFFGRID",
"x.1b : OFFGRID vertex on dnwell"
)
dnwell.with_angle(0..45).output(
"dnwell_angle",
"x.3a : non 45 degree angle dnwell"
)
nwell.ongrid(0.005).output("nwell_OFFGRID", "x.1b : OFFGRID vertex on nwell")
nwell.with_angle(0..45).output(
"nwell_angle",
"x.3a : non 45 degree angle nwell"
)
pwbm.ongrid(0.005).output("pwbm_OFFGRID", "x.1b : OFFGRID vertex on pwbm")
pwbm.with_angle(0..45).output("pwbm_angle", "x.3a : non 45 degree angle pwbm")
pwde.ongrid(0.005).output("pwde_OFFGRID", "x.1b : OFFGRID vertex on pwde")
pwde.with_angle(0..45).output("pwde_angle", "x.3a : non 45 degree angle pwde")
hvtp.ongrid(0.005).output("hvtp_OFFGRID", "x.1b : OFFGRID vertex on hvtp")
hvtp.with_angle(0..45).output("hvtp_angle", "x.3a : non 45 degree angle hvtp")
hvtr.ongrid(0.005).output("hvtr_OFFGRID", "x.1b : OFFGRID vertex on hvtr")
hvtr.with_angle(0..45).output("hvtr_angle", "x.3a : non 45 degree angle hvtr")
lvtn.ongrid(0.005).output("lvtn_OFFGRID", "x.1b : OFFGRID vertex on lvtn")
lvtn.with_angle(0..45).output("lvtn_angle", "x.3a : non 45 degree angle lvtn")
ncm.ongrid(0.005).output("ncm_OFFGRID", "x.1b : OFFGRID vertex on ncm")
ncm.with_angle(0..45).output("ncm_angle", "x.3a : non 45 degree angle ncm")
diff.ongrid(0.005).output("diff_OFFGRID", "x.1b : OFFGRID vertex on diff")
tap.ongrid(0.005).output("tap_OFFGRID", "x.1b : OFFGRID vertex on tap")
diff
.not(areaid_en.and(uhvi))
.with_angle(0..90)
.output("diff_angle", "x.2 : non 90 degree angle diff")
diff
.and(areaid_en.and(uhvi))
.with_angle(0..45)
.output("diff_angle", "x.2c : non 45 degree angle diff")
tap
.not(areaid_en.and(uhvi))
.with_angle(0..90)
.output("tap_angle", "x.2 : non 90 degree angle tap")
tap
.and(areaid_en.and(uhvi))
.with_angle(0..45)
.output("tap_angle", "x.2c : non 45 degree angle tap")
tunm.ongrid(0.005).output("tunm_OFFGRID", "x.1b : OFFGRID vertex on tunm")
tunm.with_angle(0..45).output("tunm_angle", "x.3a : non 45 degree angle tunm")
poly.ongrid(0.005).output("poly_OFFGRID", "x.1b : OFFGRID vertex on poly")
poly.with_angle(0..90).output("poly_angle", "x.2 : non 90 degree angle poly")
rpm.ongrid(0.005).output("rpm_OFFGRID", "x.1b : OFFGRID vertex on rpm")
rpm.with_angle(0..45).output("rpm_angle", "x.3a : non 45 degree angle rpm")
npc.ongrid(0.005).output("npc_OFFGRID", "x.1b : OFFGRID vertex on npc")
npc.with_angle(0..45).output("npc_angle", "x.3a : non 45 degree angle npc")
nsdm.ongrid(0.005).output("nsdm_OFFGRID", "x.1b : OFFGRID vertex on nsdm")
nsdm.with_angle(0..45).output("nsdm_angle", "x.3a : non 45 degree angle nsdm")
psdm.ongrid(0.005).output("psdm_OFFGRID", "x.1b : OFFGRID vertex on psdm")
psdm.with_angle(0..45).output("psdm_angle", "x.3a : non 45 degree angle psdm")
licon.ongrid(0.005).output("licon_OFFGRID", "x.1b : OFFGRID vertex on licon")
licon.with_angle(0..90).output(
"licon_angle",
"x.2 : non 90 degree angle licon"
)
li.ongrid(0.005).output("li_OFFGRID", "x.1b : OFFGRID vertex on li")
li.with_angle(0..45).output("li_angle", "x.3a : non 45 degree angle li")
mcon.ongrid(0.005).output("ct_OFFGRID", "x.1b : OFFGRID vertex on mcon")
mcon.with_angle(0..90).output("ct_angle", "x.2 : non 90 degree angle mcon")
vpp.ongrid(0.005).output("vpp_OFFGRID", "x.1b : OFFGRID vertex on vpp")
vpp.with_angle(0..45).output("vpp_angle", "x.3a : non 45 degree angle vpp")
m1.ongrid(0.005).output("m1_OFFGRID", "x.1b : OFFGRID vertex on m1")
m1.with_angle(0..45).output("m1_angle", "x.3a : non 45 degree angle m1")
via.ongrid(0.005).output("via_OFFGRID", "x.1b : OFFGRID vertex on via")
via.with_angle(0..90).output("via_angle", "x.2 : non 90 degree angle via")
m2.ongrid(0.005).output("m2_OFFGRID", "x.1b : OFFGRID vertex on m2")
m2.with_angle(0..45).output("m2_angle", "x.3a : non 45 degree angle m2")
via2.ongrid(0.005).output("via2_OFFGRID", "x.1b : OFFGRID vertex on via2")
via2.with_angle(0..90).output("via2_angle", "x.2 : non 90 degree angle via2")
m3.ongrid(0.005).output("m3_OFFGRID", "x.1b : OFFGRID vertex on m3")
m3.with_angle(0..45).output("m3_angle", "x.3a : non 45 degree angle m3")
via3.ongrid(0.005).output("via3_OFFGRID", "x.1b : OFFGRID vertex on via3")
via3.with_angle(0..90).output("via3_angle", "x.2 : non 90 degree angle via3")
nsm.ongrid(0.005).output("nsm_OFFGRID", "x.1b : OFFGRID vertex on nsm")
nsm.with_angle(0..45).output("nsm_angle", "x.3a : non 45 degree angle nsm")
m4.ongrid(0.005).output("m4_OFFGRID", "x.1b : OFFGRID vertex on m4")
m4.with_angle(0..45).output("m4_angle", "x.3a : non 45 degree angle m4")
via4.ongrid(0.005).output("via4_OFFGRID", "x.1b : OFFGRID vertex on via4")
via4.with_angle(0..90).output("via4_angle", "x.2 : non 90 degree angle via4")
m5.ongrid(0.005).output("m5_OFFGRID", "x.1b : OFFGRID vertex on m5")
m5.with_angle(0..45).output("m5_angle", "x.3a : non 45 degree angle m5")
pad.ongrid(0.005).output("pad_OFFGRID", "x.1b : OFFGRID vertex on pad")
pad.with_angle(0..45).output("pad_angle", "x.3a : non 45 degree angle pad")
mf.ongrid(0.005).output("mf_OFFGRID", "x.1b : OFFGRID vertex on mf")
mf.with_angle(0..90).output("mf_angle", "x.2 : non 90 degree angle mf")
hvi.ongrid(0.005).output("hvi_OFFGRID", "x.1b : OFFGRID vertex on hvi")
hvi.with_angle(0..45).output("hvi_angle", "x.3a : non 45 degree angle hvi")
hvntm.ongrid(0.005).output("hvntm_OFFGRID", "x.1b : OFFGRID vertex on hvntm")
hvntm.with_angle(0..45).output(
"hvntm_angle",
"x.3a : non 45 degree angle hvntm"
)
vhvi.ongrid(0.005).output("vhvi_OFFGRID", "x.1b : OFFGRID vertex on vhvi")
vhvi.with_angle(0..45).output("vhvi_angle", "x.3a : non 45 degree angle vhvi")
uhvi.ongrid(0.005).output("uhvi_OFFGRID", "x.1b : OFFGRID vertex on uhvi")
uhvi.with_angle(0..45).output("uhvi_angle", "x.3a : non 45 degree angle uhvi")
pwell_rs.ongrid(0.005).output(
"pwell_rs_OFFGRID",
"x.1b : OFFGRID vertex on pwell_rs"
)
pwell_rs.with_angle(0..45).output(
"pwell_rs_angle",
"x.3a : non 45 degree angle pwell_rs"
)
areaid_re.ongrid(0.005).output(
"areaid_re_OFFGRID",
"x.1b : OFFGRID vertex on areaid.re"
)
end #OFFGRID
logger.info(" ")
logger.info("Cell exclusion list:")
logger.info(" rule | cell")
if SRAM_EXCLUDE
logger.info(
" nwell.6 | sky130_fd_io__gpiov2_amux, sky130_fd_io__simple_pad_and_busses, sram"
)
logger.info(" nsd.1 | sram")
logger.info(" nsd.2 | sram")
logger.info(" psd.1 | sram")
logger.info(" psd.2 | sram")
else
logger.info(
" nwell.6 | sky130_fd_io__gpiov2_amux, sky130_fd_io__simple_pad_and_busses"
)
end #SRAM_EXCLUDE
logger.info(" ")
logger.info("release #{release}")
Reference in New Issue View Git Blame Copy Permalink