| ######################################################################################################################## |
| # 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 Via Generator for Skywaters 130nm |
| ######################################################################################################################## |
| |
| from .imported_generators.layers_definiations import * |
| import pya |
| import math |
| import pandas as pd |
| |
| |
| """ |
| Mabrains Via Generator for Skywaters 130nm |
| """ |
| |
| |
| |
| class Via_newGenerator(pya.PCellDeclarationHelper): |
| """ |
| Mabrains Via Generator for Skywaters 130nm |
| """ |
| layers = ["metal1","metal2","metal3","metal4","metal5"] |
| |
| |
| def __init__(self): |
| |
| ## Initialize super class. |
| super(Via_newGenerator, self).__init__() |
| # declare the parameters |
| #self.param("ls", self.TypeLayer, "Starting Layer", default=pya.LayerInfo(1, 0)) |
| #self.param("le", self.TypeLayer, "Ending Layer", default=pya.LayerInfo(1, 0)) |
| |
| #self.param("metal", self.TypeString, "Choose metal type AL or CU", default="AL") |
| |
| starting_layer = self.param("starting_metal", self.TypeString, "choose the starting metal",default=-4) |
| starting_layer.add_choice("Poly",-4) |
| starting_layer.add_choice("Ptap", -3) |
| starting_layer.add_choice("Ntap", -2) |
| starting_layer.add_choice("li", -1) |
| starting_layer.add_choice("metal1", 0) |
| starting_layer.add_choice("metal2", 1) |
| starting_layer.add_choice("metal3", 2) |
| starting_layer.add_choice("metal4", 3) |
| starting_layer.add_choice("metal5", 4) |
| |
| ending_layer = self.param("ending_metal",self.TypeString,"choose the ending material",default=-4) |
| ending_layer.add_choice("ptap", -3) |
| ending_layer.add_choice("Ntap", -2) |
| ending_layer.add_choice("li", -1) |
| ending_layer.add_choice("metal1",0) |
| ending_layer.add_choice("metal2",1) |
| ending_layer.add_choice("metal3",2) |
| ending_layer.add_choice("metal4",3) |
| ending_layer.add_choice("metal5",4) |
| |
| self.param("width", self.TypeDouble, "width", default=1) |
| self.param("length", self.TypeDouble, "length", default=1) |
| self.param("hv",self.TypeBoolean,"High Voltage works in case of ptap and ntap",default=False) |
| |
| |
| #self.param("metal", self.TypeString, "Choose metal type AL or CU", default="AL") |
| #self.param("via_type", self.TypeString, "Choose via type", default="via") |
| |
| #self.param("via", self.TypeLayer, "via_layer", default = pya.LayerInfo(via_lay_num,via_lay_dt), hidden = True) |
| |
| # 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 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 display_text_impl(self): |
| # Provide a descriptive text for the cell |
| return "via_array" |
| |
| 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.width = self.shape.bbox().width() |
| self.height = self.shape.bbox().height() |
| #global layer_number = self.layout.get_info(self.layer).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().p1) |
| |
| |
| def draw_metals(self,width,length,starting_metal,ending_metal): |
| l_poly = self.layout.layer(poly_lay_num,poly_lay_dt) |
| l_npc = self.layout.layer(npc_lay_num,npc_lay_dt) |
| l_nsdm = self.layout.layer(nsdm_lay_num,nsdm_lay_dt) |
| l_psdm = self.layout.layer(psdm_lay_num,psdm_lay_dt) |
| l_nwell = self.layout.layer(nwell_lay_num,nwell_lay_dt) |
| l_tap = self.layout.layer(tap_lay_num,tap_lay_dt) |
| l_li = self.layout.layer(li_lay_num,li_lay_dt) |
| l_met1 = self.layout.layer(met1_lay_num, met1_lay_dt) |
| l_met2 = self.layout.layer(met2_lay_num, met2_lay_dt) |
| l_met3 = self.layout.layer(met3_lay_num, met3_lay_dt) |
| l_met4 = self.layout.layer(met4_lay_num, met4_lay_dt) |
| l_met5 = self.layout.layer(met5_lay_num, met5_lay_dt) |
| l_hvi = self.layout.layer(hvi_lay_num,hvi_lay_dt) |
| persision = 1000 |
| width = width * persision |
| length = length * persision |
| npsdm_enc_tap = 0.125*persision |
| npc_enc = 0.1*persision |
| poly_extension = 0.09*persision |
| hv_enc_tap = 0.33*persision |
| Pass = 0 |
| for metal in range(starting_metal,ending_metal+1): |
| if metal == -4: |
| self.cell.shapes(l_poly).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width+2*poly_extension)) |
| self.cell.shapes(l_npc).insert(pya.Path([pya.Point(-npc_enc, 0), pya.Point(length+npc_enc, 0)], width+2*npc_enc)) |
| Pass = 1 |
| if metal == -3 and Pass != 1: |
| self.cell.shapes(l_tap).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width)) |
| self.cell.shapes(l_psdm).insert(pya.Path([pya.Point(-npsdm_enc_tap, 0), pya.Point(length+npsdm_enc_tap, 0)], width+2*npsdm_enc_tap)) |
| if self.hv : |
| self.cell.shapes(l_hvi).insert(pya.Path([pya.Point(-hv_enc_tap, 0), pya.Point(length+hv_enc_tap, 0)], width+2*hv_enc_tap)) |
| Pass = 1 |
| |
| if metal == -2 and Pass != 1: |
| self.cell.shapes(l_tap).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width)) |
| self.cell.shapes(l_nsdm).insert(pya.Path([pya.Point(-npsdm_enc_tap, 0), pya.Point(length+npsdm_enc_tap, 0)], width+2*npsdm_enc_tap)) |
| self.cell.shapes(l_nwell).insert(pya.Path([pya.Point(-npsdm_enc_tap, 0), pya.Point(length+npsdm_enc_tap, 0)], width+2*npsdm_enc_tap)) |
| if self.hv : |
| self.cell.shapes(l_hvi).insert(pya.Path([pya.Point(-hv_enc_tap, 0), pya.Point(length+hv_enc_tap, 0)], width+2*hv_enc_tap)) |
| self.cell.shapes(l_nwell).insert(pya.Path([pya.Point(-hv_enc_tap, 0), pya.Point(length+hv_enc_tap, 0)], width+2*hv_enc_tap)) |
| else : |
| self.cell.shapes(l_nwell).insert(pya.Path([pya.Point(-npsdm_enc_tap, 0), pya.Point(length+npsdm_enc_tap, 0)], width+2*npsdm_enc_tap)) |
| |
| if metal == -1: |
| self.cell.shapes(l_li).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width)) |
| |
| if metal == 0 : |
| self.cell.shapes(l_met1).insert(pya.Path([pya.Point(0, 0),pya.Point(length,0)],width)) |
| if metal == 1: |
| self.cell.shapes(l_met2).insert(pya.Path([pya.Point(0, 0),pya.Point(length,0)],width)) |
| if metal == 2: |
| self.cell.shapes(l_met3).insert(pya.Path([pya.Point(0, 0),pya.Point(length,0)],width)) |
| if metal == 3: |
| self.cell.shapes(l_met4).insert(pya.Path([pya.Point(0, 0),pya.Point(length,0)],width)) |
| if metal == 4: |
| self.cell.shapes(l_met5).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width)) |
| |
| self.cell.flatten(1) |
| |
| |
| def draw_vias(self,width,length,starting_metal,ending_metal): |
| l_licon = self.layout.layer(licon_lay_num, licon_lay_dt) |
| l_mcon = self.layout.layer(mcon_lay_num, mcon_lay_dt) |
| l_via = self.layout.layer(via_lay_num, via_lay_dt) |
| l_via2 = self.layout.layer(via2_lay_num, via2_lay_dt) |
| l_via3 = self.layout.layer(via3_lay_num, via3_lay_dt) |
| l_via4 = self.layout.layer(via4_lay_num, via4_lay_dt) |
| persision = 1000 |
| width = width * persision |
| length = length * persision |
| ru_dbu = 1000 |
| licon_size = 0.17*persision |
| licon_spc = 0.17*persision |
| met_licon_enc_1 = 0.04*persision |
| met_licon_enc_2 = 0.12*persision |
| mcon_size = 0.17*persision |
| mcon_spc = 0.19*persision |
| met_mcon_enc_1 = 0.03*persision |
| met_mcon_enc_2 = 0.06*persision |
| via_size = 0.15*persision |
| via_spc = 0.17*persision |
| met_via_enc_1 = 0.055*persision |
| met_via_enc_2 = 0.085*persision |
| via2_size = 0.2*persision |
| via2_spc = 0.2*persision |
| met_via2_enc_1 = 0.065 * persision |
| met_via2_enc_2 = 0.085 * persision |
| via3_size = 0.2*persision |
| via3_spc = 0.2*persision |
| met_via3_enc_1 = 0.065*persision |
| met_via3_enc_2 = 0.09*persision |
| via4_size = 0.8*persision |
| via4_spc = 0.8*persision |
| met_via4_enc = 0.310*persision |
| licon_Via = pya.Box(0, 0, licon_size , licon_size ) |
| AL_via = pya.Box(0, 0, via_size , via_size ) |
| AL_via2 = pya.Box(0, 0, via2_size, via2_size ) |
| AL_via3 = pya.Box(0, 0, via3_size , via3_size) |
| AL_via4 = pya.Box(0, 0, via4_size, via4_size) |
| if self.layout.cell("licon") == None : |
| licon_cell = self.layout.create_cell("licon") |
| else: |
| licon_cell = self.layout.cell("licon") |
| if self.layout.cell("mcon") == None : |
| mcon_cell = self.layout.create_cell("mcon") |
| else: |
| mcon_cell = self.layout.cell("mcon") |
| if self.layout.cell("via") == None: |
| via_cell = self.layout.create_cell("via") |
| else: |
| via_cell = self.layout.cell("via") |
| if self.layout.cell("via2") == None: |
| via2_cell = self.layout.create_cell("via2") |
| else: |
| via2_cell = self.layout.cell("via2") |
| if self.layout.cell("via3") == None: |
| via3_cell = self.layout.create_cell("via3") |
| else: |
| via3_cell = self.layout.cell("via3") |
| if self.layout.cell("via4") == None: |
| via4_cell = self.layout.create_cell("via4") |
| else: |
| via4_cell = self.layout.cell("via4") |
| if starting_metal == -4: |
| met_licon_enc_1 = 0.05*persision |
| met_licon_enc_2 = 0.08*persision |
| for i in range(starting_metal, ending_metal): |
| if i == -2: |
| |
| licon_cell.shapes(l_licon).insert(licon_Via) |
| num_licon_1, licon_free_spc_1 = self.number_spc_contacts(width, met_licon_enc_1, licon_spc, licon_size) |
| num_licon_2, licon_free_spc_2 = self.number_spc_contacts(length, met_licon_enc_2, licon_spc, licon_size) |
| licon_arr = pya.CellInstArray(licon_cell.cell_index(), pya.Trans( |
| pya.Point(licon_free_spc_2 / 2, -width / 2 + licon_free_spc_1 / 2)), |
| pya.Vector(licon_spc + licon_size, 0), pya.Vector(0, licon_spc + licon_size), |
| num_licon_2, num_licon_1) |
| |
| self.cell.insert(licon_arr) |
| # licon_cell.clear() |
| |
| if i == -1: |
| |
| mcon_cell.shapes(l_mcon).insert(licon_Via) |
| num_mcon_1, mcon_free_spc_1 = self.number_spc_contacts(width, met_mcon_enc_1, mcon_spc, mcon_size) |
| num_mcon_2, mcon_free_spc_2 = self.number_spc_contacts(length, met_mcon_enc_2, mcon_spc, mcon_size) |
| mcon_arr = pya.CellInstArray(mcon_cell.cell_index(), pya.Trans( |
| pya.Point(mcon_free_spc_2 / 2, -width / 2 + mcon_free_spc_1 / 2)), |
| pya.Vector(mcon_spc + mcon_size, 0), pya.Vector(0, mcon_spc + mcon_size), |
| num_mcon_2, num_mcon_1) |
| |
| self.cell.insert(mcon_arr) |
| # mcon_cell.delete() |
| if i == 0: |
| |
| via_cell.shapes(l_via).insert(AL_via) |
| num_via_1,via_free_spc_1 = self.number_spc_contacts(width,met_via_enc_1,via_spc,via_size) |
| num_via_2,via_free_spc_2 = self.number_spc_contacts(length,met_via_enc_2,via_spc,via_size) |
| via_arr = pya.CellInstArray(via_cell.cell_index(), pya.Trans(pya.Point(via_free_spc_2/2, -width/2+via_free_spc_1/2)), |
| pya.Vector(via_spc+via_size, 0), pya.Vector(0, via_spc+via_size),num_via_2,num_via_1) |
| |
| self.cell.insert(via_arr) |
| # via_cell.delete() |
| |
| |
| |
| |
| |
| |
| #self.cell.shapes(l_met2).insert(pya.Path([pya.Point(0, 0), pya.Point(length, 0)], width)) |
| if i == 1: |
| |
| via2_cell.shapes(l_via2).insert(AL_via2) |
| num_via2_1, via2_free_spc_1 = self.number_spc_contacts(width, met_via2_enc_1, via2_spc, via2_size) |
| num_via2_2, via2_free_spc_2 = self.number_spc_contacts(length, met_via2_enc_2, via2_spc, via2_size) |
| via2_arr = pya.CellInstArray(via2_cell.cell_index(), pya.Trans( |
| pya.Point(via2_free_spc_2 / 2, -width / 2 + via2_free_spc_1 / 2)), |
| pya.Vector(via2_spc + via2_size, 0), pya.Vector(0, via2_spc + via2_size), |
| num_via2_2, num_via2_1) |
| |
| self.cell.insert(via2_arr) |
| # via2_cell.delete() |
| if i == 2: |
| |
| via3_cell.shapes(l_via3).insert(AL_via3) |
| num_via3_1, via3_free_spc_1 = self.number_spc_contacts(width, met_via3_enc_1, via3_spc, via3_size) |
| num_via3_2, via3_free_spc_2 = self.number_spc_contacts(length, met_via3_enc_2, via3_spc, via3_size) |
| via3_arr = pya.CellInstArray(via3_cell.cell_index(), pya.Trans( |
| pya.Point(via3_free_spc_2 / 2, -width / 2 + via3_free_spc_1 / 2)), |
| pya.Vector(via3_spc + via3_size, 0), |
| pya.Vector(0, via3_spc + via3_size), |
| num_via3_2, num_via3_1) |
| |
| self.cell.insert(via3_arr) |
| # via3_cell.delete() |
| pass |
| if i == 3: |
| |
| via4_cell.shapes(l_via4).insert(AL_via4) |
| num_via4_1, via4_free_spc_1 = self.number_spc_contacts(width, met_via4_enc, via4_spc, via4_size) |
| num_via4_2, via4_free_spc_2 = self.number_spc_contacts(length, met_via4_enc, via4_spc, via4_size) |
| via4_arr = pya.CellInstArray(via4_cell.cell_index(), pya.Trans( |
| pya.Point(via4_free_spc_2 / 2, -width / 2 + via4_free_spc_1 / 2)), |
| pya.Vector(via4_spc + via4_size, 0), |
| pya.Vector(0, via4_spc + via4_size), |
| num_via4_2, num_via4_1) |
| self.cell.insert(via4_arr) |
| # via4_cell.delete() |
| |
| # via_cell.clear() |
| # self.cell.flatten(1) |
| |
| self.layout.convert_cell_to_static(licon_cell.cell_index()) |
| self.layout.convert_cell_to_static(mcon_cell.cell_index()) |
| self.layout.convert_cell_to_static(via_cell.cell_index()) |
| self.layout.convert_cell_to_static(via2_cell.cell_index()) |
| self.layout.convert_cell_to_static(via3_cell.cell_index()) |
| self.layout.convert_cell_to_static(via4_cell.cell_index()) |
| |
| |
| |
| |
| |
| |
| |
| def produce_impl(self): |
| |
| |
| # compute the circle |
| #pts = [] |
| #da = math.pi * 2 / 4 |
| #for i in range(0, 4): |
| #pts.append(pya.Point.from_dpoint(pya.DPoint(ru_dbu * math.cos(i * da), ru_dbu * math.sin(i * da)))) |
| #self.cell.shapes(l_met1).insert(pya.Box(0,0,self.width,self.height)) |
| # create the shape |
| self.draw_metals(self.width,self.length,self.starting_metal,self.ending_metal) |
| self.draw_vias(self.width,self.length,self.starting_metal,self.ending_metal) |
| self.cell.flatten(1) |
| self.layout.cleanup() |
| |
| |
| |
| |
| |
| print(self.ending_metal) |
| #CU_via = pya.Box(0,0,0.18*ru_dbu,0.18*ru_dbu) |
| # if self.metal == "CU": |
| # self.cell.shapes(l_via).insert(CU_via) |
| # else: |
| # if self.via_type == "via": |
| # self.cell.shapes(l_via).insert(AL_via) |
| # elif self.via_type == "via2": |
| # self.cell.shapes(l_via2).insert(AL_via2) |
| # elif self.via_type == "via3": |
| # self.cell.shapes(l_via3).insert(AL_via3) |
| # else : |
| # self.cell.shapes(l_via4).insert(AL_via4) |
| |
| |
| |
