| ######################################################################################################################## |
| # 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 PMOS 1.8V Generator for Skywaters 130nm |
| ######################################################################################################################## |
| import pya |
| import math |
| from .layers_definiations import * |
| |
| |
| |
| class PMOS18(pya.PCellDeclarationHelper): |
| """ |
| Mabrains Via Generator for Skywaters 130nm |
| """ |
| |
| def __init__(self): |
| ## Initialize super class. |
| super(PMOS18, self).__init__() |
| |
| # declare the parameters |
| |
| self.param("w", self.TypeDouble, "Width", default=0.42) |
| self.param("l", self.TypeDouble, "Length", default=0.15) |
| self.param("nf", self.TypeInt, "Number of Fingers", default=1) |
| self.param("gr", self.TypeBoolean, "guard ring", default=1) |
| self.param("dsa", self.TypeInt, "drain and source number of contacts", default=1) |
| |
| #self.param("down_connection", self.TypeBoolean, "Gate connection down", default=1) |
| #self.param("up_connection", self.TypeBoolean, "Gate connection up", default=0) |
| #self.param("alternate_connection", self.TypeBoolean, "Alternate gate connection", default=0) |
| connection_option = self.param("connection", self.TypeString, "Connection Option", default="Connection Up") |
| connection_option.add_choice("Connection Up", 0) |
| connection_option.add_choice("Connection Down", 1) |
| connection_option.add_choice("Alternate connection", 2) |
| self.param("n", self.TypeInt, "alternate factor", default=1) |
| |
| |
| # Below shows how to create hidden parameter is used to determine whether the radius has changed |
| # or the "s" handle has been moved |
| ## self.param("ru", self.TypeDouble, "Radius", default = 0.0, hidden = True) |
| ## self.param("rd", self.TypeDouble, "Double radius", readonly = True) |
| |
| def display_text_impl(self): |
| # Provide a descriptive text for the cell |
| return "PMOS18(L=" + ('%.3f' % self.l) + ",W=" + ('%.3f' % self.w) + ")" |
| |
| |
| def coerce_parameters_impl(self): |
| # We employ coerce_parameters_impl to decide whether the handle or the |
| # numeric parameter has changed (by comparing against the effective |
| # radius ru) and set ru to the effective radius. We also update the |
| # numerical value or the shape, depending on which on has not changed. |
| pass |
| |
| def can_create_from_shape_impl(self): |
| # Implement the "Create PCell from shape" protocol: we can use any shape which |
| # has a finite bounding box |
| return self.shape.is_box() or self.shape.is_polygon() or self.shape.is_path() |
| # |
| def parameters_from_shape_impl(self): |
| # # Implement the "Create PCell from shape" protocol: we set r and l from the shape's |
| # # bounding box width and layer |
| self.r = self.shape.bbox().width() * self.layout.dbu / 2 |
| self.l = self.layout.get_info(self.layer) |
| # |
| def transformation_from_shape_impl(self): |
| #Implement the "Create PCell from shape" protocol: we use the center of the shape's |
| # # bounding box to determine the transformation |
| return pya.Trans(self.shape.bbox().center()) |
| |
| def number_spc_contacts(self,box_width, min_enc, cont_spc, cont_width): |
| 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 produce_impl(self): |
| PERCISION = 1000 |
| nwell_extension = 0.18*PERCISION |
| # precision value for scaling |
| liconpoly_spc = 0.055 * PERCISION |
| source_shared = 1 |
| # 1 for source_shared 0 for no nf turned into no of multipliers |
| multipliers = 1 |
| diff_spc = 0.27 * PERCISION |
| npsdm_enc_diff = .125 * PERCISION |
| # the extension of n+ or p+ layer beyond diff to define it's type |
| npsdm_spc_opposite = 0.13 * PERCISION |
| # the spacing of different regions of doping |
| npsdm_spc = 0.38 * PERCISION |
| # the spacing of the same type regions of doping |
| alternate = 0 |
| mcon_size = 0.17 * PERCISION |
| mcon_spc = 0.19 * PERCISION |
| # if 0 alternate 1 gate_connection_up 2 gate_connection_down |
| |
| # and the channel length is low todo find the length in code |
| |
| diffusion_width_big = self.dsa * mcon_size + (self.dsa - 1) * mcon_spc + 2 * liconpoly_spc |
| # diffusion width between fingers |
| diffusion_width_small = diffusion_width_big |
| diffusion_width_big_samedirection = diffusion_width_big |
| # diffusion width between fingers if the gates in the same direction |
| # first diffusion and last diffusion width #todo check if matter |
| if self.connection == 1 or self.connection == 0: |
| # if gates in the same direction |
| diffusion_width_big = diffusion_width_big_samedirection |
| # if gates in the same direction enlarge diffusion to get through drc |
| # todo make the last and first diffusion the same as the between |
| |
| nf = self.nf # number of fingers |
| channel_length = self.l * PERCISION |
| |
| if source_shared == 0: |
| # if no source sharing nf = 1 and repetition become multiplier |
| nf = 1 |
| |
| if nf == 1: |
| diffusion_total_width = channel_length + diffusion_width_big + diffusion_width_small |
| # todo :correct the diffusion_total_width of singel finger |
| |
| diffusion_total_width = nf * channel_length + (nf - 1) * diffusion_width_big + 2 * diffusion_width_big |
| channel_width = self.w * PERCISION |
| fingers_connected = True |
| gate_connection_up = False |
| min_channel_width = channel_width |
| diff_min_width = 0.28 |
| poly_min_width = 0.15 |
| poly_diff_min_enc = 0.13 * PERCISION |
| polylicon_spc_diff = 0.19 * PERCISION |
| |
| licon_size = 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 |
| via_size = 0.15 * PERCISION |
| via_spc = 0.17 * PERCISION |
| via_met_enc = 0.085 * PERCISION |
| if self.connection == 1: |
| # gate_connection down todo why |
| diffusion_width_big = diffusion_width_big_samedirection |
| |
| li_width = 0.17 * PERCISION |
| |
| # number of vertical licon's diff todo use the function |
| spc_for_licon = channel_width - 2 * diff_licon_enc_vertical |
| num_ver_licon = int(((spc_for_licon / licon_size) + 1) / 2) |
| |
| # number of vertical mcon diff |
| num_ver_mcon = int((channel_width + mcon_spc) / (mcon_spc + mcon_size)) |
| free_spc_mcon_diff = (channel_width - (num_ver_mcon * (mcon_spc + mcon_size) - mcon_spc)) |
| |
| # calculate free space for licon |
| free_space_diff_licon = channel_width - (2 * num_ver_licon - 1) * licon_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 |
| l_nsdm = self.layout.layer(nsdm_lay_num, nsdm_lay_dt) # nsdm source drain impalnt |
| l_psdm = self.layout.layer(psdm_lay_num, psdm_lay_dt) # psdm source drain impaln |
| l_licon = self.layout.layer(licon_lay_num, licon_lay_dt) # licon local interconnect |
| 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) |
| |
| ##cells## |
| top_nmos_cell = self.layout.create_cell("top_nmos") |
| nmos_cell = self.layout.create_cell("nmos") |
| gate_cell = self.layout.create_cell("gate") |
| licon_cell = self.layout.create_cell("licon") |
| licon_between_fingers_cell = self.layout.create_cell("licon_between_fingers") |
| up_gate_connection = self.layout.create_cell("up_gate_connection") |
| down_gate_connection = self.layout.create_cell("down_gate_connection") |
| li_between_fingers_cell = self.layout.create_cell("li_between_fingers") |
| mcon_tran_sides_cell = self.layout.create_cell("mcon_transistor_sides") |
| mcon_between_fingers_cell = self.layout.create_cell("mcon_between_fingers") |
| ## |
| |
| 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 |
| |
| for finger in range(nf): |
| gate_box = pya.Box(diffusion_width_big + x, -poly_diff_min_enc, channel_length + diffusion_width_big + x, |
| channel_width + poly_diff_min_enc) |
| |
| self.cell.shapes(l_poly).insert(gate_box) |
| x += channel_length + diffusion_width_big |
| |
| gate_box = pya.Box(diffusion_width_big, -poly_diff_min_enc, channel_length + diffusion_width_big, |
| 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 |
| |
| # 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_small, -polylicon_spc_diff, channel_length + diffusion_width_small, |
| -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 - npc_enc_gate, contact_gate_box_down.p1.y - npc_enc_gate, |
| contact_gate_box_down.p2.x + 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) |
| num_hori_licon_diff, free_space_licon_diff_hor = self.number_spc_contacts(diffusion_width_big, 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_big) |
| |
| num_hori_mcon_diff, free_space_mcon_diff_hor = self.number_spc_contacts(diffusion_width_big, 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 |
| |
| li_between_fingers_path = pya.Path([pya.Point(diffusion_width_big / 2, diff_box.p1.y), |
| pya.Point(diffusion_width_big / 2, diff_box.p2.y)], |
| diffusion_width_big) |
| met1_between_fingers_path = pya.Path([pya.Point(diffusion_width_big / 2, diff_box.p1.y - mcon_m1_enc), |
| pya.Point(diffusion_width_big / 2, diff_box.p2.y + mcon_m1_enc)], |
| diffusion_width_big) |
| |
| 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_small, channel_width + poly_diff_min_enc, |
| channel_length + diffusion_width_small, |
| 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) |
| |
| 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) |
| |
| nmos_cell.shapes(l_diff).insert(diff_box) |
| nmos_cell.shapes(l_psdm).insert(nsdm_box) |
| # gate_cell.shapes(l_poly).insert(gate_box) |
| # nmos_cell.shapes(l_li).insert(li_diff_left) |
| # nmos_cell.shapes(l_li).insert(li_diff_right) |
| # nmos_cell.shapes(l_met1).insert(met1_diff_left) |
| # nmos_cell.shapes(l_met1).insert(met1_diff_right) |
| |
| 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, mcon_spc, |
| mcon_size) |
| shift_distance = (self.n) * (diffusion_width_big + channel_length) # shift distance for alternate mode |
| |
| 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 |
| |
| 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 |
| # licon_box_down.p1.y = licon_box_down.p1.y + 2*licon_size |
| # licon_box_down.p2.y = licon_box_down.p2.y+2*licon_size |
| # y_sh += 2*licon_size |
| # down_gate_connection.shapes(l_licon).insert(licon_box_down) |
| # y_sh -= 2*licon_size |
| |
| self.cell.shapes(l_li).insert(li_box_down) |
| self.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) |
| self.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) |
| self.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) |
| self.cell.shapes(l_li).insert(li_box_up) |
| self.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 |
| # licon_box_down.p1.y = licon_box_down.p1.y + 2*licon_size |
| # licon_box_down.p2.y = licon_box_down.p2.y+2*licon_size |
| # y_sh += 2*licon_size |
| # down_gate_connection.shapes(l_licon).insert(licon_box_down) |
| # y_sh -= 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) |
| self.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) |
| self.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_licon).insert(licon_box_up) |
| up_gate_connection.shapes(l_npc).insert(npc_box_up) |
| # nmos_cell.shapes(l_li).insert(li_path_up) |
| |
| # licon_cell.shapes(l_licon).insert(licon_diff_contact_left) |
| # licon_cell.shapes(l_licon).insert(licon_diff_contact_right) |
| |
| # licon_cell.shapes(l_licon).insert(licon_between_fingers) |
| # hor_licon_diff_arr = pya.CellInstArray(licon_cell.cell_index(),pya.Trans(pya.Point(0,0)),pya.Vector(2*licon_size,0),pya.Vector(0,0),num_hori_licon_diff,0) |
| |
| # licon_between_fingers_cell.insert(hor_licon_diff_arr) |
| |
| # mcon_tran_sides_cell.shapes(l_mcon).insert(mcon_diff_left) |
| # mcon_tran_sides_cell.shapes(l_mcon).insert(mcon_diff_right) |
| 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) |
| |
| down_iteration = self.n |
| up_iteration = self.n |
| down_iteration_distance = diffusion_width_big + channel_length # distance to iterate down gate connection |
| up_iteration_distance = down_iteration_distance |
| iteration_distance_group = 2 * self.n * (diffusion_width_big + channel_length) |
| if self.connection == 1: # for gate_connection_down_only |
| down_iteration = nf |
| up_iteration = 0 |
| down_iteration_distance = diffusion_width_big + channel_length |
| iteration_distance_group = 0 |
| |
| elif self.connection == 0: # for gate_connection_up_only |
| up_iteration = nf |
| down_iteration = 0 |
| up_iteration_distance = diffusion_width_big + channel_length |
| shift_distance = 0 |
| 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(nf / (2 * self.n))) |
| 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, |
| max(1, nf / self.n - math.ceil(nf / (2 * self.n)))) |
| nmos_cell.insert(upper_connection) |
| |
| # fingers = pya.CellInstArray(gate_cell.cell_index(), pya.Trans(pya.Point(0, 0)), |
| # pya.Vector(diffusion_width_big + channel_length, 0), pya.Vector(0, 0), nf, 0) |
| # nmos_cell.insert(fingers) |
| |
| # iteration_distance_licon = diffusion_width_small - diff_licon_enc_horzintal + channel_length + (diffusion_width_big-licon_size)/2 |
| |
| if 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_big + channel_length, 0), |
| num_ver_licon, |
| nf + 1) |
| nmos_cell.insert(licon_between_fingers_arr) |
| |
| # licon_diff_contact = pya.CellInstArray(licon_cell.cell_index(), pya.Trans(pya.Point(0, 0)), pya.Vector(0, 0), |
| # pya.Vector(0, 2 * licon_size), 0, num_ver_licon) |
| # nmos_cell.insert(licon_diff_contact) |
| |
| if nf : |
| licon_between_fingers_arr = pya.CellInstArray(li_between_fingers_cell.cell_index(), |
| pya.Trans(pya.Point(0, 0)), |
| pya.Vector(diffusion_width_big + channel_length, 0), |
| pya.Vector(0, 0), |
| nf + 1, 1) |
| nmos_cell.insert(licon_between_fingers_arr) |
| |
| # mcon_diff_sides_arr = pya.CellInstArray(mcon_tran_sides_cell.cell_index(), |
| # pya.Trans(pya.Point(0, free_spc_mcon_diff / 2)), |
| # pya.Vector(0, mcon_spc + mcon_size), pya.Vector(0, 0), num_ver_mcon, 0) |
| # nmos_cell.insert(mcon_diff_sides_arr) |
| |
| if nf : |
| mcon_diff_bet_fing = pya.CellInstArray(mcon_between_fingers_cell.cell_index(), pya.Trans(pya.Point(0, 0)), |
| pya.Vector(diffusion_width_big + channel_length, 0), |
| pya.Vector(0, mcon_spc + mcon_size), nf + 1, num_ver_mcon) |
| nmos_cell.insert(mcon_diff_bet_fing) |
| |
| 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) |
| |
| self.cell.insert(multiple_transistors) |
| |
| tap_width = 0.26 * PERCISION |
| if self.gr: |
| 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 |
| |
| else: # gate_down |
| guard_down = contact_gate_box_down.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) |
| |
| 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) |
| self.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) |
| self.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) |
| self.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) |
| self.cell.shapes(l_met1).insert(gurad_ring_metal1_left) |
| |
| self.cell.shapes(l_met2).insert(gurad_ring_metal1_upper) |
| self.cell.shapes(l_met2).insert(gurad_ring_metal1_lower) |
| self.cell.shapes(l_met2).insert(gurad_ring_metal1_right) |
| self.cell.shapes(l_met2).insert(gurad_ring_metal1_left) |
| |
| self.cell.shapes(l_tap).insert(guard_ring_path) |
| self.cell.shapes(l_nsdm).insert(psdm_guard_ring_path) |
| self.cell.shapes(l_li).insert(guard_ring_path) |
| # top_nmos_cell.shapes(l_met1).insert(guard_ring_path) |
| |
| distance_cont_guard_vert = guard_ring_upper_left.y - guard_ring_lower_left.y |
| num_licon_guard_vert, free_spc_licon_guard_left = self.number_spc_contacts(distance_cont_guard_vert, |
| 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_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) |
| self.cell.shapes(l_licon).insert(licon_guard_box_left) |
| self.cell.shapes(l_licon).insert(licon_guard_box_right) |
| licon_guard_p1_y += 2 * licon_size |
| licon_guard_p2_y += 2 * licon_size |
| |
| num_mcon_guard_vert, free_spc_mcon_guard_left = self.number_spc_contacts(distance_cont_guard_vert, |
| 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_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) |
| self.cell.shapes(l_mcon).insert(mcon_guard_box_left) |
| self.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 |
| |
| num_via_guard_vert, free_spc_via_guard_left = self.number_spc_contacts(distance_cont_guard_vert, |
| 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_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) |
| self.cell.shapes(l_via).insert(via_guard_box_left) |
| self.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) |
| self.cell.shapes(l_licon).insert(licon_guard_box_upper) |
| self.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) |
| self.cell.shapes(l_mcon).insert(mcon_guard_box_upper) |
| self.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) |
| self.cell.shapes(l_via).insert(via_guard_box_upper) |
| self.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 |
| |
| self.cell.shapes(l_nwell).insert( |
| psdm_guard_ring_path.bbox().enlarge(nwell_extension , nwell_extension)) |
| |
