| ######################################################################################################################## |
| # Copyright 2022 Mabrains Company LLC |
| # |
| # Licensed under the LGPL v2.1 License (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| ## |
| ######################################################################################################################## |
| ## |
| # This file is authored by: |
| # - <Mina Maksimous> <mina_maksimous@mabrains.com> |
| ## |
| ######################################################################################################################## |
| |
| ######################################################################################################################## |
| # Mabrains Company LLC |
| ## |
| # Mabrains NMOS 1.8V Generator for Skywaters 130nm |
| ######################################################################################################################## |
| from .layers_definiations import * |
| import pya |
| import math |
| import os |
| import sys |
| |
| # path = os.path.abspath("layers_definiations") |
| # sys.path.insert(1, path) |
| |
| |
| # cell_extend_layer = layout.layer(1, 1) |
| # fill_shape = pya.Box(0,0,100*1000,100*1000) |
| # top_cell.shapes(cell_extend_layer).insert(fill_shape) |
| |
| |
| ######################################################################################################################### |
| # Exceptions |
| ######################################################################################################################### |
| class Error(Exception): |
| """Base class for other exceptions""" |
| pass |
| |
| |
| class small_channel_length(Error): |
| """Raised When the channel length is < 0.15u""" |
| pass |
| |
| |
| class small_channel_width(Error): |
| """Raised When the channel width is < 0.42u""" |
| pass |
| |
| |
| class small_drain_source_area(Error): |
| """Raised When the dsa < 1""" |
| pass |
| |
| |
| class gate_connection_error(Error): |
| """Raised when the connection value is not 0,1,2""" |
| pass |
| |
| |
| class alternate_connection_error(Error): |
| """Raised when the n factor don't play well with alternate factor""" |
| pass |
| |
| |
| class nf_error(Error): |
| """Raised when the nf < 1""" |
| pass |
| |
| |
| class layout_not_defined(Error): |
| """layout is not defined""" |
| pass |
| |
| |
| class max_drain_source_area(Error): |
| """Max Drain Source Area""" |
| |
| |
| class no_subcircuit_in_netlist(Error): |
| """no subcircuit inn netlist""" |
| ######################################################################################################################### |
| |
| |
| # Drawing functions |
| ######################################################################################################################### |
| class nmos18_device: |
| def __init__(self, w=0.42, l=0.15, nf=1, gr=1, |
| dsa=2, |
| connection=0, |
| n=1, |
| x_offest=0, |
| y_offest=0, |
| conn_num=0, |
| connection_labels = 1, |
| gate_connection="gate_connection_", |
| gate_connection_up="gate_connection_up_", |
| gate_connection_down="gate_connection_down_", |
| drain_connection="drain_connection_", |
| source_connection="source_connection_", |
| connected_gates = 1, |
| layout=None): |
| self.w = w |
| self.l = l |
| self.nf = nf |
| self.gr = gr |
| self.dsa = dsa |
| self.connection = connection |
| |
| self.n = n |
| self.x_offest = x_offest |
| self.y_offest = y_offest |
| self.conn_num = str(conn_num) |
| self.gate_connection = gate_connection |
| self.gate_connection_up = gate_connection_up |
| self.gate_connection_down = gate_connection_down |
| self.drain_connection = drain_connection |
| self.source_connection = source_connection |
| self.layout = layout |
| self.connected_gates = connected_gates |
| self.connection_labels = connection_labels |
| self.l_diff_implant = self.layout.layer(nsdm_lay_num, nsdm_lay_dt) |
| self.l_guard = self.layout.layer( |
| psdm_lay_num, psdm_lay_dt) # guard ring implant layer |
| self.cell_str = "nmos18_w" + str(self.w).replace(".", "p") + "u_l" + str(self.l).replace(".", "p") + "u_nf" + str( |
| self.nf) + "_drain_area" + str(self.dsa) + "_gate_connection" + str(self.connection) + "alt" + str(self.n) |
| |
| def number_spc_contacts(self, box_width, min_enc, cont_spc, cont_width): |
| """ Calculate number of cantacts in a given dimensions and the free space for symmetry. |
| |
| By getting the min enclosure,the width of the box,the width of the cont. or via |
| and the spacing between cont. or via |
| |
| Parameters |
| ---------- |
| box_width : double |
| The length you place the via or cont. in |
| |
| min_enc : double |
| the spacing between the edge of the box and the first via or cont. |
| |
| cont_spc : double |
| the spacing between different via's or cont |
| |
| cont_width: double |
| the cont. or via width in the same direction |
| |
| """ |
| |
| spc_cont = box_width - 2 * min_enc |
| num_cont = int((spc_cont + cont_spc) / (cont_width + cont_spc)) |
| free_spc = box_width - (num_cont * cont_width + |
| (num_cont - 1) * cont_spc) |
| return num_cont, free_spc |
| |
| def draw_guard_ring(self, layout, x, y, guard_width, guard_height, precision, tap_width=0.26, cell=None,guard_label=''): |
| # psdm source drain impaln |
| l_psdm = layout.layer(psdm_lay_num, psdm_lay_dt) |
| l_nsdm = layout.layer(nsdm_lay_num, nsdm_lay_dt) |
| # licon local interconnect |
| l_licon = layout.layer(licon_lay_num, licon_lay_dt) |
| l_li = layout.layer(li_lay_num, li_lay_dt) |
| l_mcon = layout.layer(mcon_lay_num, mcon_lay_dt) |
| l_met1 = layout.layer(met1_lay_num, met1_lay_dt) |
| l_tap = layout.layer(tap_lay_num, tap_lay_dt) |
| l_via = layout.layer(via_lay_num, via_lay_dt) |
| l_met2 = layout.layer(met2_lay_num, met2_lay_dt) |
| PERCISION = precision |
| guard_width *= PERCISION |
| guard_height *= PERCISION |
| npsdm_enc_diff = .125 * PERCISION |
| licon_size = 0.17 * PERCISION |
| mcon_m1_enc = 0.03 * PERCISION |
| via_met_enc = 0.085*PERCISION |
| mcon_size = 0.17 * PERCISION |
| mcon_spc = 0.19 * PERCISION |
| via_size = 0.15 * PERCISION |
| via_spc = 0.17 * PERCISION |
| tap_width = tap_width * PERCISION |
| guard_ring_lower_left = pya.Point(x, y) |
| guard_ring_upper_left = pya.Point(x, y+guard_height) |
| guard_ring_upper_right = pya.Point(x+guard_width, y+guard_height) |
| guard_ring_lower_right = pya.Point( |
| guard_ring_upper_right.x, guard_ring_lower_left.y) |
| guard_ring_path = pya.Path( |
| [guard_ring_lower_left, guard_ring_upper_left, guard_ring_upper_right, guard_ring_lower_right, |
| guard_ring_lower_left], tap_width, tap_width / 2, 0) |
| psdm_guard_ring_path = pya.Path( |
| [guard_ring_lower_left, guard_ring_upper_left, guard_ring_upper_right, guard_ring_lower_right, |
| guard_ring_lower_left], tap_width + 2 * npsdm_enc_diff, (tap_width + 2 * npsdm_enc_diff) / 2, 0) |
| gurad_ring_metal1_upper = pya.Path([guard_ring_upper_left, guard_ring_upper_right], tap_width, tap_width / 2, |
| tap_width / 2) |
| cell.shapes(l_met1).insert(gurad_ring_metal1_upper) |
| gurad_ring_metal1_lower = pya.Path([guard_ring_lower_left, guard_ring_lower_right], tap_width, tap_width / 2, |
| tap_width / 2) |
| cell.shapes(l_met1).insert(gurad_ring_metal1_lower) |
| gurad_ring_metal1_right = pya.Path([guard_ring_lower_right, guard_ring_upper_right], tap_width, tap_width / 2, |
| tap_width / 2) |
| cell.shapes(l_met1).insert(gurad_ring_metal1_right) |
| gurad_ring_metal1_left = pya.Path([guard_ring_lower_left, guard_ring_upper_left], tap_width, tap_width / 2, |
| tap_width / 2) |
| cell.shapes(l_met1).insert(gurad_ring_metal1_left) |
| cell.shapes(l_met2).insert(gurad_ring_metal1_upper) |
| cell.shapes(l_met2).insert(gurad_ring_metal1_lower) |
| cell.shapes(l_met2).insert(gurad_ring_metal1_right) |
| cell.shapes(l_met2).insert(gurad_ring_metal1_left) |
| cell.shapes(l_tap).insert(guard_ring_path) |
| # if type == 'p': |
| # cell.shapes(l_psdm).insert(psdm_guard_ring_path) |
| # if type == 'n': |
| cell.shapes(self.l_guard).insert(psdm_guard_ring_path) |
| cell.shapes(l_li).insert(guard_ring_path) |
| # top_nmos_cell.shapes(l_met1).insert(guard_ring_path) |
| |
| distance_cont_guard_vert_licon = guard_ring_upper_left.y - \ |
| guard_ring_lower_left.y - licon_size - 2*licon_size |
| num_licon_guard_vert, free_spc_licon_guard_left = self.number_spc_contacts(distance_cont_guard_vert_licon, |
| mcon_m1_enc, |
| licon_size, licon_size) |
| licon_guard_p1_x_left = guard_ring_lower_left.x - licon_size / 2 |
| licon_guard_p1_x_right = guard_ring_lower_right.x - licon_size / 2 |
| licon_guard_p1_y = guard_ring_lower_left.y + \ |
| free_spc_licon_guard_left / 2 + licon_size/2 + licon_size |
| licon_guard_p2_x_left = licon_guard_p1_x_left + licon_size |
| licon_guard_p2_x_right = licon_guard_p1_x_right + licon_size |
| licon_guard_p2_y = licon_guard_p1_y + licon_size |
| # drawing vertical licon in guard_ring |
| for licon in range(num_licon_guard_vert): |
| licon_guard_box_left = pya.Box(licon_guard_p1_x_left, licon_guard_p1_y, licon_guard_p2_x_left, |
| licon_guard_p2_y) |
| licon_guard_box_right = pya.Box(licon_guard_p1_x_right, licon_guard_p1_y, licon_guard_p2_x_right, |
| licon_guard_p2_y) |
| cell.shapes(l_licon).insert(licon_guard_box_left) |
| cell.shapes(l_licon).insert(licon_guard_box_right) |
| licon_guard_p1_y += 2 * licon_size |
| licon_guard_p2_y += 2 * licon_size |
| distance_cont_guard_vert_mcon = guard_ring_upper_left.y - \ |
| guard_ring_lower_left.y - mcon_size - 2*mcon_spc |
| num_mcon_guard_vert, free_spc_mcon_guard_left = self.number_spc_contacts(distance_cont_guard_vert_mcon, mcon_m1_enc, |
| mcon_spc, mcon_size) |
| mcon_guard_p1_x_left = guard_ring_lower_left.x - mcon_size / 2 |
| mcon_guard_p1_x_right = guard_ring_lower_right.x - mcon_size / 2 |
| mcon_guard_p1_y = guard_ring_lower_left.y + \ |
| free_spc_mcon_guard_left / 2 + mcon_size/2 + mcon_spc |
| mcon_guard_p2_x_left = mcon_guard_p1_x_left + mcon_size |
| mcon_guard_p2_x_right = mcon_guard_p1_x_right + mcon_size |
| mcon_guard_p2_y = mcon_guard_p1_y + licon_size |
| for mcon in range(num_mcon_guard_vert): |
| mcon_guard_box_left = pya.Box( |
| mcon_guard_p1_x_left, mcon_guard_p1_y, mcon_guard_p2_x_left, mcon_guard_p2_y) |
| mcon_guard_box_right = pya.Box(mcon_guard_p1_x_right, mcon_guard_p1_y, mcon_guard_p2_x_right, |
| mcon_guard_p2_y) |
| cell.shapes(l_mcon).insert(mcon_guard_box_left) |
| cell.shapes(l_mcon).insert(mcon_guard_box_right) |
| mcon_guard_p1_y += mcon_size + mcon_spc |
| mcon_guard_p2_y += mcon_size + mcon_spc |
| distance_cont_guard_vert_via = guard_ring_upper_left.y - \ |
| guard_ring_lower_left.y - via_size - 2*via_spc |
| num_via_guard_vert, free_spc_via_guard_left = self.number_spc_contacts(distance_cont_guard_vert_via, |
| via_met_enc, |
| via_spc, via_size) |
| via_guard_p1_x_left = guard_ring_lower_left.x - via_size / 2 |
| via_guard_p1_x_right = guard_ring_lower_right.x - via_size / 2 |
| via_guard_p1_y = guard_ring_lower_left.y + \ |
| free_spc_via_guard_left / 2 + via_size/2 + via_spc |
| via_guard_p2_x_left = via_guard_p1_x_left + via_size |
| via_guard_p2_x_right = via_guard_p1_x_right + via_size |
| via_guard_p2_y = via_guard_p1_y + via_size |
| for via in range(num_via_guard_vert): |
| via_guard_box_left = pya.Box(via_guard_p1_x_left, via_guard_p1_y, via_guard_p2_x_left, |
| via_guard_p2_y) |
| via_guard_box_right = pya.Box(via_guard_p1_x_right, via_guard_p1_y, via_guard_p2_x_right, |
| via_guard_p2_y) |
| cell.shapes(l_via).insert(via_guard_box_left) |
| cell.shapes(l_via).insert(via_guard_box_right) |
| via_guard_p1_y += via_size + via_spc |
| via_guard_p2_y += via_size + via_spc |
| distance_cont_guard_hori = ( |
| guard_ring_upper_right.x - guard_ring_upper_left.x) - 2 * mcon_spc |
| num_licon_guard_hori, free_spc_licon_guard_hori = self.number_spc_contacts(distance_cont_guard_hori, |
| mcon_m1_enc, |
| licon_size, licon_size) |
| licon_guard_p1_x_hori = guard_ring_lower_left.x + \ |
| free_spc_licon_guard_hori / 2 + mcon_spc |
| licon_guard_p1_y_lower = guard_ring_lower_left.y - licon_size / 2 |
| licon_guard_p1_y_upper = guard_ring_upper_left.y - licon_size / 2 |
| licon_guard_p2_x_hori = licon_guard_p1_x_hori + licon_size |
| licon_guard_p2_y_upper = guard_ring_upper_left.y + licon_size / 2 |
| licon_guard_p2_y_lower = guard_ring_lower_left.y + licon_size / 2 |
| for licon in range(num_licon_guard_hori): |
| licon_guard_box_upper = pya.Box(licon_guard_p1_x_hori, licon_guard_p1_y_upper, licon_guard_p2_x_hori, |
| licon_guard_p2_y_upper) |
| licon_guard_box_lower = pya.Box(licon_guard_p1_x_hori, licon_guard_p1_y_lower, licon_guard_p2_x_hori, |
| licon_guard_p2_y_lower) |
| cell.shapes(l_licon).insert(licon_guard_box_upper) |
| cell.shapes(l_licon).insert(licon_guard_box_lower) |
| licon_guard_p1_x_hori += 2 * licon_size |
| licon_guard_p2_x_hori += 2 * licon_size |
| num_mcon_guard_hori, free_spc_mcon_guard_hori = self.number_spc_contacts(distance_cont_guard_hori, |
| mcon_m1_enc, |
| mcon_spc, mcon_size) |
| mcon_guard_p1_x_hori = guard_ring_lower_left.x + \ |
| free_spc_mcon_guard_hori / 2 + mcon_spc |
| mcon_guard_p1_y_lower = guard_ring_lower_left.y - mcon_size / 2 |
| mcon_guard_p1_y_upper = guard_ring_upper_left.y - mcon_size / 2 |
| mcon_guard_p2_x_hori = mcon_guard_p1_x_hori + mcon_size |
| mcon_guard_p2_y_upper = guard_ring_upper_left.y + mcon_size / 2 |
| mcon_guard_p2_y_lower = guard_ring_lower_left.y + mcon_size / 2 |
| for mcon in range(num_mcon_guard_hori): |
| mcon_guard_box_upper = pya.Box(mcon_guard_p1_x_hori, mcon_guard_p1_y_upper, |
| mcon_guard_p2_x_hori, |
| mcon_guard_p2_y_upper) |
| mcon_guard_box_lower = pya.Box(mcon_guard_p1_x_hori, mcon_guard_p1_y_lower, |
| mcon_guard_p2_x_hori, |
| mcon_guard_p2_y_lower) |
| cell.shapes(l_mcon).insert(mcon_guard_box_upper) |
| cell.shapes(l_mcon).insert(mcon_guard_box_lower) |
| mcon_guard_p1_x_hori += mcon_size + mcon_spc |
| mcon_guard_p2_x_hori += mcon_size + mcon_spc |
| num_via_guard_hori, free_spc_via_guard_hori = self.number_spc_contacts(distance_cont_guard_hori, |
| via_met_enc, |
| via_spc, via_size) |
| via_guard_p1_x_hori = guard_ring_lower_left.x + \ |
| free_spc_via_guard_hori / 2 + via_spc |
| via_guard_p1_y_lower = guard_ring_lower_left.y - via_size / 2 |
| via_guard_p1_y_upper = guard_ring_upper_left.y - via_size / 2 |
| via_guard_p2_x_hori = via_guard_p1_x_hori + via_size |
| via_guard_p2_y_upper = guard_ring_upper_left.y + via_size / 2 |
| via_guard_p2_y_lower = guard_ring_lower_left.y + via_size / 2 |
| for via in range(num_via_guard_hori): |
| via_guard_box_upper = pya.Box(via_guard_p1_x_hori, via_guard_p1_y_upper, |
| via_guard_p2_x_hori, |
| via_guard_p2_y_upper) |
| via_guard_box_lower = pya.Box(via_guard_p1_x_hori, via_guard_p1_y_lower, |
| via_guard_p2_x_hori, |
| via_guard_p2_y_lower) |
| cell.shapes(l_via).insert(via_guard_box_upper) |
| cell.shapes(l_via).insert(via_guard_box_lower) |
| via_guard_p1_x_hori += via_size + via_spc |
| via_guard_p2_x_hori += via_size + via_spc |
| |
| gurad_ring_metal1_right_bbox = gurad_ring_metal1_right.bbox() |
| if guard_label != '': |
| guard_connection_text = pya.Text(guard_label, |
| gurad_ring_metal1_right_bbox.center().x, |
| gurad_ring_metal1_right_bbox.center().y,) |
| if self.connection_labels: |
| cell.shapes(self.l_met2_label).insert(guard_connection_text) |
| |
| |
| def draw_nmos(self): |
| """ |
| Draw nmos 1.8v |
| |
| Parameters |
| ---------- |
| w : double |
| Channel width of the transistor |
| l : double |
| Channel length of the transistor |
| nf : integer |
| number of fingers |
| gr : bool |
| guard ring option |
| dsa : integer max 8 |
| Area of drain and source |
| connection : 0 , 1 , 2 |
| 0 : gate connection up |
| 1 : gate connection down |
| 2 : gate connection alternate by factor n |
| n : integer |
| Alternate factor flip the gates every n in case of alternate option |
| x_offest : offset of the origin in the x_direction |
| y_offest : offset of the origin in the y_direction |
| conn_num : number of the connection |
| """ |
| # Netnames |
| print(self.connection) |
| if self.gate_connection_up == "gate_connection_up_": |
| gate_connection_text_up = self.gate_connection_up + \ |
| str(self.conn_num) |
| else: |
| gate_connection_text_up = self.gate_connection_up |
| |
| if self.gate_connection_down == "gate_connection_down_": |
| gate_connection_text_down = self.gate_connection_down + \ |
| str(self.conn_num) |
| else: |
| gate_connection_text_down = self.gate_connection_down |
| |
| if self.gate_connection == "gate_connection_": |
| gate_connection_text_down = self.gate_connection + \ |
| str(self.conn_num) |
| gate_connection_text_up = self.gate_connection + str(self.conn_num) |
| else: |
| gate_connection_text_down = self.gate_connection |
| gate_connection_text_up = self.gate_connection |
| |
| if self.drain_connection == "drain_connection_": |
| drain_connection_text_input = self.drain_connection + self.conn_num |
| else: |
| drain_connection_text_input = self.drain_connection |
| |
| if self.source_connection == "source_connection_": |
| source_connection_text_input = self.source_connection + self.conn_num |
| else: |
| source_connection_text_input = self.source_connection |
| # Exceptions |
| if self.w < 0.42: |
| raise small_channel_width |
| |
| if self.l < 0.15: |
| raise small_channel_length |
| |
| if self.nf < 1: |
| raise nf_error |
| |
| if self.dsa < 1: |
| raise small_drain_source_area |
| |
| if self.dsa > 8: |
| raise max_drain_source_area |
| |
| if self.connection != 1 and self.connection != 0 and self.connection != 2 and self.connection != 3 and self.connection != 4: |
| raise gate_connection_error |
| |
| if self.connection == 2 and self.nf % self.n != 0: |
| raise alternate_connection_error |
| |
| if self.layout is None: |
| raise layout_not_defined |
| |
| conn_num = str(self.conn_num) |
| # layout = pya.Layout() |
| |
| # precision value for scaling |
| |
| PERCISION = 1 / self.layout.dbu |
| liconpoly_spc = 0.055 * PERCISION |
| |
| # 1 for source_shared 0 for no nf turned into no of multipliers |
| source_shared = 1 |
| multipliers = 1 |
| diff_spc = 0.27 * PERCISION |
| |
| # the extension of n+ or p+ layer beyond diff to define it's type |
| npsdm_enc_diff = .125 * PERCISION |
| |
| # the spacing of different regions of doping |
| npsdm_spc_opposite = 0.135 * PERCISION |
| |
| # the spacing of the same type regions of doping |
| npsdm_spc = 0.38 * PERCISION |
| |
| # mcon _contact_size |
| mcon_size = 0.17 * PERCISION |
| |
| # mcon_spacing |
| mcon_spc = 0.19 * PERCISION |
| |
| # and the channel length is low todo find the length in code |
| |
| diffusion_width = self.dsa * mcon_size + \ |
| (self.dsa - 1) * mcon_spc + 2 * liconpoly_spc + 0.01*PERCISION |
| |
| channel_length = int(self.l * PERCISION) |
| |
| if source_shared == 0: |
| # if no source sharing nf = 1 and repetition become multiplier |
| self.nf = 1 |
| |
| if self.nf == 1: |
| # if self.nf = 1 alternative doesn't make sense so the default is up |
| if self.connection == 2: |
| self.connection = 0 |
| # todo :correct the diffusion_total_width of singel finger |
| |
| diffusion_total_width = self.nf * channel_length + \ |
| (self.nf - 1) * diffusion_width + 2 * diffusion_width |
| channel_width = self.w * PERCISION |
| |
| diff_min_width = 0.28 |
| poly_min_width = 0.15 |
| poly_diff_min_enc = 0.13 * PERCISION |
| polylicon_spc_diff = 0.22 * PERCISION |
| |
| licon_size = 0.17 * PERCISION |
| licon_spc = 0.17 * PERCISION |
| |
| diff_licon_enc_vertical = 0.08 * PERCISION |
| diff_licon_enc_horzintal = 0.04 * PERCISION |
| liconpoly_enc_vertical = 0.05 * PERCISION |
| liconpoly_enc_horizontal = 0.08 * PERCISION |
| li_licon_enc = 0.08 * PERCISION |
| npc_enc_gate = 0.1 * PERCISION |
| m1_width = 0.17 * PERCISION |
| mcon_m1_enc = 0.03 * PERCISION |
| mcon_m1_enc_adjacent = 0.06 * PERCISION |
| via_size = 0.15 * PERCISION |
| via_spc = 0.17 * PERCISION |
| via_met_enc = 0.085 * PERCISION |
| li_width = 0.17 * PERCISION |
| nwell_extension = 0.18 * PERCISION |
| |
| # number of vertical licon's diff todo use the function |
| num_ver_licon, free_space_diff_licon = self.number_spc_contacts(channel_width, diff_licon_enc_vertical, licon_spc, |
| licon_size) |
| # number of vertical mcon diff |
| num_ver_mcon, free_spc_mcon_diff = self.number_spc_contacts( |
| channel_width, mcon_m1_enc, mcon_spc, mcon_size) |
| |
| # layers_definations |
| l_diff = self.layout.layer(diff_lay_num, diff_lay_dt) # Diffusion |
| l_poly = self.layout.layer(poly_lay_num, poly_lay_dt) # Poly |
| # nsdm source drain impalnt |
| l_nsdm = self.layout.layer(nsdm_lay_num, nsdm_lay_dt) |
| # psdm source drain impaln |
| l_psdm = self.layout.layer(psdm_lay_num, psdm_lay_dt) |
| # licon local interconnect |
| l_licon = self.layout.layer(licon_lay_num, licon_lay_dt) |
| l_npc = self.layout.layer(npc_lay_num, npc_lay_dt) |
| l_li = self.layout.layer(li_lay_num, li_lay_dt) |
| l_mcon = self.layout.layer(mcon_lay_num, mcon_lay_dt) |
| l_met1 = self.layout.layer(met1_lay_num, met1_lay_dt) |
| l_tap = self.layout.layer(tap_lay_num, tap_lay_dt) |
| l_nwell = self.layout.layer(nwell_lay_num, nwell_lay_dt) |
| l_via = self.layout.layer(via_lay_num, via_lay_dt) |
| l_met2 = self.layout.layer(met2_lay_num, met2_lay_dt) |
| l_prbndry = self.layout.layer(prbndry_lay_num, prbndry_lay_dt) |
| l_poly_label = self.layout.layer(poly_label_lay_num, poly_label_lay_dt) |
| l_met1_label = self.layout.layer(met1_label_lay_num, met1_label_lay_dt) |
| self.l_met2_label = self.layout.layer(met2_label_lay_num,met2_label_lay_dt) |
| |
| ##cells## |
| # top_nmos_cell = layout.create_cell("top_nmos_"+str(w)+"_"+str(l)) |
| |
| self.nmos_cell = self.layout.create_cell(self.cell_str) |
| licon_between_fingers_cell = self.layout.create_cell( |
| "licon_between_fingers") |
| |
| li_between_fingers_cell = self.layout.create_cell("li_between_fingers") |
| mcon_between_fingers_cell = self.layout.create_cell( |
| "mcon_between_fingers") |
| ## |
| self.diff_box = pya.Box(0, 0, diffusion_total_width, channel_width) |
| diff_box = pya.Box(0, 0, diffusion_total_width, channel_width) |
| |
| # main diff box |
| nsdm_box = pya.Box(-npsdm_enc_diff, -npsdm_enc_diff, diffusion_total_width + npsdm_enc_diff, |
| channel_width + npsdm_enc_diff) |
| # source drain implant diff |
| x = 0 |
| |
| # draw the gate fingers |
| for finger in range(self.nf): |
| gate_box = pya.Box(diffusion_width + x, -poly_diff_min_enc, channel_length + diffusion_width + x, |
| channel_width + poly_diff_min_enc) |
| |
| self.nmos_cell.shapes(l_poly).insert(gate_box) |
| |
| x += channel_length + diffusion_width |
| |
| gate_box = pya.Box(diffusion_width, -poly_diff_min_enc, channel_length + diffusion_width, |
| channel_width + poly_diff_min_enc) |
| ######################################################################################################################### |
| # connection of gate box dimensions |
| ######################################################################################################################### |
| |
| contact_gate_width = 2 * liconpoly_enc_horizontal + licon_size |
| contact_gate_height = 2 * liconpoly_enc_vertical + 3 * licon_size |
| num_horizontal_licon_gate = 1 |
| |
| free_spc_licon_gate = contact_gate_width - \ |
| (2 * num_horizontal_licon_gate - 1) * licon_size |
| if channel_length > contact_gate_width: |
| # calculate number of horizontal licon in gate connection todo use function to do |
| contact_gate_width = channel_length |
| spc_for_licon_gate = channel_length - 2 * liconpoly_enc_horizontal |
| num_horizontal_licon_gate = int( |
| ((spc_for_licon_gate / licon_size) + 1) / 2) |
| free_spc_licon_gate = channel_length - \ |
| (2 * num_horizontal_licon_gate - 1) * licon_size |
| elif channel_length < contact_gate_width and self.nf != 1 and self.dsa == 1: |
| self.connection = 2 |
| |
| if self.connection == 0 or self.connection == 2: |
| up_gate_connection = self.layout.create_cell("up_gate_connection") |
| if self.connection == 1 or self.connection == 2: |
| down_gate_connection = self.layout.create_cell( |
| "down_gate_connection") |
| |
| # contacte_gate_box |
| contact_gate_box_down = pya.Box(gate_box.center().x - contact_gate_width / 2, |
| -polylicon_spc_diff - contact_gate_height, |
| gate_box.center().x + contact_gate_width / 2, -polylicon_spc_diff) |
| neck_box_down = pya.Box(diffusion_width, -polylicon_spc_diff, channel_length + diffusion_width, |
| -poly_diff_min_enc) |
| # licon_box_down = pya.Box(contact_gate_box_down.center().x - licon_size/2, contact_gate_box_down.center().y-(licon_size/2),contact_gate_box_down.center().x + licon_size/2,contact_gate_box_down.center().y + licon_size/2) |
| npc_box_down = pya.Box(contact_gate_box_down.p1.x - 1.6*npc_enc_gate, contact_gate_box_down.p1.y - npc_enc_gate, |
| contact_gate_box_down.p2.x + 1.6*npc_enc_gate, contact_gate_box_down.p2.y + npc_enc_gate) |
| li_box_down = pya.Box(diff_box.p1.x, contact_gate_box_down.p1.y, |
| diff_box.p1.x + multipliers * diffusion_total_width + ( |
| 2 * multipliers - 2) * npsdm_enc_diff + (multipliers - 1) * npsdm_spc, |
| contact_gate_box_down.p2.y) |
| |
| gate_connection_text_down = pya.Text(gate_connection_text_up, li_box_down.center().x, |
| li_box_down.center().y) |
| |
| num_hori_licon_diff, free_space_licon_diff_hor = self.number_spc_contacts(diffusion_width, liconpoly_spc, licon_size, |
| licon_size) |
| |
| sh1 = 0 |
| for hor_licon_diff in range(num_hori_licon_diff): |
| licon_between_fingers = pya.Box(free_space_licon_diff_hor / 2 + sh1, |
| free_space_diff_licon / 2, free_space_licon_diff_hor / 2 + licon_size + sh1, |
| free_space_diff_licon / 2 + licon_size) |
| licon_between_fingers_cell.shapes( |
| l_licon).insert(licon_between_fingers) |
| sh1 += 2 * licon_size |
| |
| # print(num_hori_licon_diff,free_space_licon_diff_hor,diffusion_width) |
| |
| num_hori_mcon_diff, free_space_mcon_diff_hor = self.number_spc_contacts( |
| diffusion_width, 0, mcon_spc, mcon_size) |
| sh2 = 0 |
| for hor_mcon_diff in range(num_hori_mcon_diff): |
| mcon_between_fingers = pya.Box(free_space_mcon_diff_hor / 2 + sh2, |
| free_spc_mcon_diff / 2, |
| free_space_mcon_diff_hor / 2 + sh2 + mcon_size, |
| free_spc_mcon_diff / 2 + mcon_size) |
| mcon_between_fingers_cell.shapes( |
| l_mcon).insert(mcon_between_fingers) |
| sh2 += mcon_size + mcon_spc |
| |
| if channel_length < 0.17 * PERCISION: |
| li_width_reduction = 0.17 * PERCISION - channel_length |
| else: |
| li_width_reduction = 0 |
| |
| li_between_fingers_path = pya.Path([pya.Point(diffusion_width / 2, diff_box.p1.y), |
| pya.Point(diffusion_width / 2, diff_box.p2.y)], |
| diffusion_width - li_width_reduction) |
| met1_between_fingers_path = pya.Path([pya.Point(diffusion_width / 2, diff_box.p1.y - mcon_m1_enc), |
| pya.Point(diffusion_width / 2, diff_box.p2.y + mcon_m1_enc)], |
| diffusion_width) |
| |
| contact_gate_box_up = pya.Box(gate_box.center().x - contact_gate_width / 2, channel_width + polylicon_spc_diff, |
| gate_box.center().x + contact_gate_width / 2, |
| channel_width + polylicon_spc_diff + contact_gate_height) |
| neck_box_up = pya.Box(diffusion_width, channel_width + poly_diff_min_enc, |
| channel_length + diffusion_width, |
| channel_width + polylicon_spc_diff) |
| licon_box_up = pya.Box(contact_gate_box_up.center().x - licon_size / 2, |
| contact_gate_box_up.center().y - (licon_size / 2), |
| contact_gate_box_up.center().x + licon_size / 2, |
| contact_gate_box_up.center().y + licon_size / 2) |
| npc_box_up = pya.Box(contact_gate_box_up.p1.x - 1.6 * npc_enc_gate, contact_gate_box_up.p1.y - npc_enc_gate, |
| contact_gate_box_up.p2.x + 1.6 * npc_enc_gate, contact_gate_box_up.p2.y + npc_enc_gate) |
| |
| |
| li_path_up = pya.Path( |
| [pya.Point(diff_box.p1.x, licon_box_up.center().y), |
| pya.Point(diff_box.p2.x, licon_box_up.center().y)], |
| li_width) |
| |
| licon_diff_contact_left = pya.Box(diff_box.p1.x + diff_licon_enc_horzintal, free_space_diff_licon / 2, |
| diff_licon_enc_horzintal + licon_size, free_space_diff_licon / 2 + licon_size) |
| li_diff_left = pya.Path([pya.Point(licon_diff_contact_left.center().x, diff_box.p1.y), |
| pya.Point(licon_diff_contact_left.center().x, diff_box.p2.y)], li_width) |
| met1_diff_left = pya.Path([pya.Point(licon_diff_contact_left.center().x, diff_box.p1.y - mcon_m1_enc), |
| pya.Point(licon_diff_contact_left.center().x, diff_box.p2.y + mcon_m1_enc)], |
| m1_width + 2 * mcon_m1_enc) |
| # drain_connection |
| x_offset_drain = 0 |
| met1_diff_left_bbox = met1_diff_left.bbox() |
| for drain in range(math.ceil((self.nf + 1) / 2)): |
| drain_connection_text = pya.Text(drain_connection_text_input, |
| met1_diff_left_bbox.center().x + self.x_offest + x_offset_drain, |
| met1_diff_left_bbox.center().y + self.y_offest) |
| if self.connection_labels : |
| self.nmos_cell.shapes(l_met1_label).insert(drain_connection_text) |
| x_offset_drain = x_offset_drain + 2 * \ |
| (channel_length + diffusion_width) |
| |
| # source connection |
| x_offset_source = channel_length + diffusion_width |
| for source in range(((self.nf + 1) - math.ceil((self.nf + 1) / 2))): |
| source_connection_text = pya.Text(source_connection_text_input, |
| met1_diff_left_bbox.center().x + self.x_offest + x_offset_source, |
| met1_diff_left_bbox.center().y + self.y_offest) |
| if self.connection_labels: |
| self.nmos_cell.shapes(l_met1_label).insert(source_connection_text) |
| x_offset_source = x_offset_source + 2 * \ |
| (channel_length + diffusion_width) |
| |
| mcon_diff_left = pya.Box(licon_diff_contact_left.p1.x, |
| 0, licon_diff_contact_left.p1.x + mcon_size, mcon_size) |
| |
| licon_diff_contact_right = pya.Box(diff_box.p2.x - diff_licon_enc_horzintal - licon_size, |
| free_space_diff_licon / 2, |
| diff_box.p2.x - diff_licon_enc_horzintal, |
| free_space_diff_licon / 2 + licon_size) |
| li_diff_right = pya.Path([pya.Point(licon_diff_contact_right.center().x, diff_box.p1.y), |
| pya.Point(licon_diff_contact_right.center().x, diff_box.p2.y)], li_width) |
| mcon_diff_right = pya.Box(licon_diff_contact_right.p1.x, 0, licon_diff_contact_right.p1.x + mcon_size, |
| mcon_size) |
| met1_diff_right = pya.Path([pya.Point(licon_diff_contact_right.center().x, diff_box.p1.y - mcon_m1_enc), |
| pya.Point(licon_diff_contact_right.center().x, diff_box.p2.y + mcon_m1_enc)], |
| m1_width + 2 * mcon_m1_enc) |
| |
| self.nmos_cell.shapes(l_diff).insert(diff_box) |
| # if mos_type == 'n': |
| self.nmos_cell.shapes(self.l_diff_implant).insert(nsdm_box) |
| # if mos_type == 'p': |
| # self.nmos_cell.shapes(l_psdm).insert(nsdm_box) |
| if self.connected_gates == 0: |
| li_box_down = contact_gate_box_down |
| li_box_up = contact_gate_box_up |
| num_ver_mcon_gates, free_spc_mcon_gates_v = self.number_spc_contacts(li_box_down.height(), mcon_m1_enc, mcon_spc, |
| mcon_size) |
| num_hor_mcon_gates, free_spc_mcon_gates_h = self.number_spc_contacts(li_box_down.width(), mcon_m1_enc_adjacent, mcon_spc, |
| mcon_size) |
| # shift distance for alternate mode |
| shift_distance = self.n * (diffusion_width + channel_length) |
| if self.connection != 3: |
| if self.connection == 1 or self.connection == 2: |
| down_gate_connection.shapes(l_poly).insert(contact_gate_box_down) |
| down_gate_connection.shapes(l_poly).insert(neck_box_down) |
| |
| y_sh = 0 |
| if self.connection_labels: |
| self.nmos_cell.shapes(l_met1_label).insert( |
| gate_connection_text_down) |
| p1_x = contact_gate_box_down.p1.x + free_spc_licon_gate / 2 |
| p1_y = contact_gate_box_down.p1.y + liconpoly_enc_vertical |
| p2_x = contact_gate_box_down.p1.x + free_spc_licon_gate / 2 + licon_size |
| p2_y = contact_gate_box_down.p1.y + liconpoly_enc_vertical + licon_size |
| for licon_ct in range(num_horizontal_licon_gate): |
| licon_box_down = pya.Box(p1_x, p1_y, p2_x, p2_y) |
| |
| down_gate_connection.shapes(l_licon).insert(licon_box_down) |
| p1_y += 2 * licon_size |
| p2_y += 2 * licon_size |
| licon_box_down = pya.Box(p1_x, p1_y, p2_x, p2_y) |
| down_gate_connection.shapes(l_licon).insert(licon_box_down) |
| p1_y -= 2 * licon_size |
| p2_y -= 2 * licon_size |
| |
| p1_x += 2 * licon_size |
| p2_x += 2 * licon_size |
| if self.connected_gates == 0: # the gate has contacts but no connection |
| down_gate_connection.shapes(l_li).insert(contact_gate_box_down) |
| down_gate_connection.shapes(l_met1).insert(contact_gate_box_down) |
| else: |
| self.nmos_cell.shapes(l_li).insert(li_box_down) |
| self.nmos_cell.shapes(l_met1).insert(li_box_down) |
| down_gate_connection.shapes(l_npc).insert(npc_box_down) |
| |
| x_mcon_gates = li_box_down.p1.x + free_spc_mcon_gates_h / 2 |
| y_mcon_gates = li_box_down.p1.y + free_spc_mcon_gates_v / 2 |
| y1_mcon_gates = y_mcon_gates + mcon_size |
| |
| for mcon in range(num_hor_mcon_gates): |
| x1_mcon_gates = x_mcon_gates + mcon_size |
| mcon_box_gate = pya.Box( |
| x_mcon_gates, y_mcon_gates, x1_mcon_gates, y1_mcon_gates) |
| if self.connected_gates == 0: # the gate has contacts but no connection |
| down_gate_connection.shapes(l_mcon).insert(mcon_box_gate) |
| else: |
| self.nmos_cell.shapes(l_mcon).insert(mcon_box_gate) |
| for mcon1 in range(num_ver_mcon_gates - 1): |
| y_mcon_gates += mcon_size + mcon_spc |
| y1_mcon_gates += mcon_size + mcon_spc |
| mcon_box_gate = pya.Box( |
| x_mcon_gates, y_mcon_gates, x1_mcon_gates, y1_mcon_gates) |
| if self.connected_gates == 0: # the gate has contacts but no connection |
| down_gate_connection.shapes(l_mcon).insert(mcon_box_gate) |
| else: |
| self.nmos_cell.shapes(l_mcon).insert(mcon_box_gate) |
| y_mcon_gates -= (num_ver_mcon_gates - 1) * \ |
| mcon_size + (num_ver_mcon_gates - 1) * mcon_spc |
| y1_mcon_gates -= (num_ver_mcon_gates - 1) * \ |
| mcon_size + (num_ver_mcon_gates - 1) * mcon_spc |
| x_mcon_gates += mcon_size + mcon_spc |
| x1_mcon_gates += mcon_size + mcon_spc |
| |
| if self.connection == 0 or self.connection == 2: |
| if self.connection == 0: |
| shift_distance = 0 |
| up_gate_connection.shapes(l_poly).insert(contact_gate_box_up) |
| up_gate_connection.shapes(l_poly).insert(neck_box_up) |
| p1_x = contact_gate_box_up.p1.x + free_spc_licon_gate / 2 |
| p1_y = contact_gate_box_up.p1.y + liconpoly_enc_vertical |
| p2_x = contact_gate_box_up.p1.x + free_spc_licon_gate / 2 + licon_size |
| p2_y = contact_gate_box_up.p1.y + liconpoly_enc_vertical + licon_size |
| li_box_up = pya.Box(diff_box.p1.x, contact_gate_box_up.p1.y, |
| diff_box.p1.x + multipliers * diffusion_total_width + ( |
| 2 * multipliers - 2) * npsdm_enc_diff + ( |
| multipliers - 1) * npsdm_spc, contact_gate_box_up.p2.y) |
| |
| gate_connection_text_up = pya.Text(gate_connection_text_up, li_box_up.center().x, |
| li_box_up.center().y) |
| if self.connection_labels: |
| self.nmos_cell.shapes(l_met1_label).insert(gate_connection_text_up) |
| if self.connected_gates == 0: # the gate has contacts but no connection |
| li_box_up = contact_gate_box_up |
| up_gate_connection.shapes(l_li).insert(contact_gate_box_up) |
| up_gate_connection.shapes(l_met1).insert(contact_gate_box_up) |
| else: |
| self.nmos_cell.shapes(l_li).insert(li_box_up) |
| self.nmos_cell.shapes(l_met1).insert(li_box_up) |
| for licon_ct in range(num_horizontal_licon_gate): |
| licon_box_up = pya.Box(p1_x, p1_y, p2_x, p2_y) |
| |
| up_gate_connection.shapes(l_licon).insert(licon_box_up) |
| p1_y += 2 * licon_size |
| p2_y += 2 * licon_size |
| licon_box_up = pya.Box(p1_x, p1_y, p2_x, p2_y) |
| up_gate_connection.shapes(l_licon).insert(licon_box_up) |
| p1_y -= 2 * licon_size |
| p2_y -= 2 * licon_size |
| |
| p1_x += 2 * licon_size |
| p2_x += 2 * licon_size |
| |
| x_mcon_gates = li_box_up.p1.x + free_spc_mcon_gates_h / 2 |
| y_mcon_gates = li_box_up.p1.y + free_spc_mcon_gates_v / 2 |
| y1_mcon_gates = y_mcon_gates + mcon_size |
| |
| for mcon in range(num_hor_mcon_gates): |
| x1_mcon_gates = x_mcon_gates + mcon_size |
| mcon_box_gate = pya.Box( |
| x_mcon_gates, y_mcon_gates, x1_mcon_gates, y1_mcon_gates) |
| if self.connected_gates == 0 : |
| up_gate_connection.shapes(l_mcon).insert(mcon_box_gate) |
| else: |
| self.nmos_cell.shapes(l_mcon).insert(mcon_box_gate) |
| for mcon1 in range(num_ver_mcon_gates - 1): |
| y_mcon_gates += mcon_size + mcon_spc |
| y1_mcon_gates += mcon_size + mcon_spc |
| mcon_box_gate = pya.Box( |
| x_mcon_gates, y_mcon_gates, x1_mcon_gates, y1_mcon_gates) |
| if self.connected_gates == 0 : |
| up_gate_connection.shapes(l_mcon).insert(mcon_box_gate) |
| else: |
| self.nmos_cell.shapes(l_mcon).insert(mcon_box_gate) |
| y_mcon_gates -= (num_ver_mcon_gates - 1) * \ |
| mcon_size + (num_ver_mcon_gates - 1) * mcon_spc |
| y1_mcon_gates -= (num_ver_mcon_gates - 1) * \ |
| mcon_size + (num_ver_mcon_gates - 1) * mcon_spc |
| x_mcon_gates += mcon_size + mcon_spc |
| x1_mcon_gates += mcon_size + mcon_spc |
| up_gate_connection.shapes(l_npc).insert(npc_box_up) |
| |
| mcon_between_fingers_cell.shapes(l_mcon).insert(mcon_between_fingers) |
| |
| li_between_fingers_cell.shapes(l_li).insert(li_between_fingers_path) |
| li_between_fingers_cell.shapes( |
| l_met1).insert(met1_between_fingers_path) |
| |
| if self.connection != 3: |
| down_iteration = self.n |
| up_iteration = self.n |
| # distance to iterate down gate connection |
| down_iteration_distance = diffusion_width + channel_length |
| up_iteration_distance = down_iteration_distance |
| iteration_distance_group = 2 * self.n * \ |
| (diffusion_width + channel_length) |
| if self.connection == 1: # for gate_connection_down_only |
| down_iteration = self.nf |
| up_iteration = 0 |
| down_iteration_distance = diffusion_width + channel_length |
| iteration_distance_group = 0 |
| bottom_connection = pya.CellInstArray(down_gate_connection.cell_index(), pya.Trans(pya.Point(0, 0)), |
| pya.Vector( |
| down_iteration_distance, 0), |
| pya.Vector( |
| iteration_distance_group, 0), down_iteration, |
| math.ceil(self.nf / (2 * self.n))) |
| self.nmos_cell.insert(bottom_connection) |
| |
| elif self.connection == 0: # for gate_connection_up_only |
| up_iteration = self.nf |
| down_iteration = 0 |
| up_iteration_distance = diffusion_width + channel_length |
| shift_distance = 0 |
| iteration_distance_group = 0 |
| |
| repition_b = self.nf / self.n - math.ceil(self.nf / (2 * self.n)) |
| |
| if self.nf == 1: |
| repition_b = 1 |
| |
| upper_connection = pya.CellInstArray(up_gate_connection.cell_index(), pya.Trans(pya.Point(shift_distance, 0)), |
| pya.Vector( |
| up_iteration_distance, 0), |
| pya.Vector(iteration_distance_group, 0), up_iteration, repition_b) |
| |
| self.nmos_cell.insert(upper_connection) |
| |
| else: |
| bottom_connection = pya.CellInstArray(down_gate_connection.cell_index(), pya.Trans(pya.Point(0, 0)), |
| pya.Vector( |
| down_iteration_distance, 0), |
| pya.Vector( |
| iteration_distance_group, 0), down_iteration, |
| math.ceil(self.nf / (2 * self.n))) |
| self.nmos_cell.insert(bottom_connection) |
| |
| upper_connection = pya.CellInstArray(up_gate_connection.cell_index(), pya.Trans(pya.Point(shift_distance, 0)), |
| pya.Vector( |
| up_iteration_distance, 0), |
| pya.Vector( |
| iteration_distance_group, 0), up_iteration, |
| self.nf / self.n - math.ceil(self.nf / (2 * self.n))) |
| |
| self.nmos_cell.insert(upper_connection) |
| |
| self.nmos_cell.flatten(True) |
| |
| |
| if self.nf: |
| licon_between_fingers_arr = pya.CellInstArray(licon_between_fingers_cell.cell_index(), |
| pya.Trans( |
| pya.Point(0, 0)), |
| pya.Vector( |
| 0, 2 * licon_size), |
| pya.Vector( |
| diffusion_width + channel_length, 0), |
| num_ver_licon, |
| self.nf + 1) |
| self.nmos_cell.insert(licon_between_fingers_arr) |
| |
| self.nmos_cell.flatten(True) |
| |
| if self.nf: |
| li_between_fingers_arr = pya.CellInstArray(li_between_fingers_cell.cell_index(), |
| pya.Trans( |
| pya.Point(0, 0)), |
| pya.Vector( |
| diffusion_width + channel_length, 0), |
| pya.Vector(0, 0), |
| self.nf + 1, 1) |
| |
| self.nmos_cell.insert(li_between_fingers_arr) |
| |
| self.nmos_cell.flatten(True) |
| |
| if self.nf: |
| mcon_diff_bet_fing = pya.CellInstArray(mcon_between_fingers_cell.cell_index(), pya.Trans(pya.Point(0, 0)), |
| pya.Vector( |
| diffusion_width + channel_length, 0), |
| pya.Vector(0, mcon_spc + mcon_size), self.nf + 1, num_ver_mcon) |
| self.nmos_cell.insert(mcon_diff_bet_fing) |
| |
| self.nmos_cell.flatten(True) |
| |
| # multiple_transistors = pya.CellInstArray(nmos_cell.cell_index(), pya.Trans(pya.Point(0, 0)), |
| # pya.Vector(diffusion_total_width + 2 * npsdm_enc_diff + npsdm_spc, 0), |
| # pya.Vector(0, 0), multipliers, 1) |
| |
| # top_nmos_cell.insert(multiple_transistors) |
| tap_width = 0.26 * PERCISION |
| if self.connection == 0: # gate_up |
| guard_up = contact_gate_box_up.p2.y |
| guard_down = diff_box.p1.y |
| elif self.connection == 2: # alternate_mode |
| guard_up = contact_gate_box_up.p2.y |
| guard_down = contact_gate_box_down.p1.y |
| |
| elif self.connection == 1: # gate_down |
| guard_down = contact_gate_box_down.p1.y |
| guard_up = diff_box.p2.y |
| |
| else: #No gate connection |
| guard_down = diff_box.p1.y |
| guard_up = diff_box.p2.y |
| |
| guard_ring_lower_left = pya.Point(diff_box.p1.x - 2 * npsdm_enc_diff - npsdm_spc_opposite - tap_width / 2, |
| guard_down - 2 * npsdm_enc_diff - npsdm_spc_opposite - tap_width / 2) |
| guard_ring_upper_left = pya.Point(guard_ring_lower_left.x, |
| guard_up + 2 * npsdm_enc_diff + npsdm_spc_opposite + tap_width / 2) |
| guard_ring_upper_right = pya.Point( |
| multipliers * diffusion_total_width + 2 * multipliers * npsdm_enc_diff + ( |
| multipliers - 1) * npsdm_spc + npsdm_spc_opposite + tap_width / 2, guard_ring_upper_left.y) |
| guard_ring_lower_right = pya.Point( |
| guard_ring_upper_right.x, guard_ring_lower_left.y) |
| # primitive_boundry |
| prbndry_box = pya.Box(guard_ring_lower_left, guard_ring_upper_right) |
| guard_ring_width = (guard_ring_lower_right.x - |
| guard_ring_lower_left.x)/PERCISION |
| guard_ring_height = (guard_ring_upper_right.y - |
| guard_ring_lower_right.y)/PERCISION |
| self.nmos_cell.shapes(l_prbndry).insert(prbndry_box) |
| |
| if self.gr: |
| pass |
| self.draw_guard_ring(layout=self.layout, x=guard_ring_lower_left.x, y=guard_ring_lower_left.y, |
| guard_width=guard_ring_width, guard_height=guard_ring_height, precision=PERCISION, cell=self.nmos_cell) |
| |
| return self.nmos_cell |
