Abstracted LEF added. Params for array wordline layers.

compiler/base/lef.py

@@ -10,6 +10,8 @@ from tech import layer_names
 import os
 import shutil
 from globals import OPTS
+from vector import vector
+from pin_layout import pin_layout
 
 
 class lef:
@@ -68,13 +70,63 @@ class lef:
     def lef_write(self, lef_name):
         """ Write the entire lef of the object to the file. """
 
-        if OPTS.drc_exe and OPTS.drc_exe[0] == "magic":
-            self.magic_lef_write(lef_name)
-            return
+        if OPTS.detailed_lef:
+            debug.info(3, "Writing detailed LEF to {0}".format(lef_name))
+            self.detailed_lef_write(lef_name)
+        else:
+            debug.info(3, "Writing abstract LEF to {0}".format(lef_name))
+            # Can possibly use magic lef write to create the LEF
+            # if OPTS.drc_exe and OPTS.drc_exe[0] == "magic":
+            #     self.magic_lef_write(lef_name)
+            #     return
+            self.abstract_lef_write(lef_name)
 
-        debug.info(3, "Writing detailed LEF to {0}".format(lef_name))
+    def abstract_lef_write(self, lef_name):
+        # To maintain the indent level easily
+        self.indent = "" 
 
-        self.indent = "" # To maintain the indent level easily
+        self.lef  = open(lef_name, "w")
+        self.lef_write_header()
+
+        # Start with blockages on all layers the size of the block
+        # minus the pin escape margin (hard coded to 4 x m3 pitch)
+        # These are a pin_layout to use their geometric functions
+        perimeter_margin = self.m3_pitch
+        self.blockages = {}
+        for layer_name in self.lef_layers:
+            self.blockages[layer_name]=[]
+        for layer_name in self.lef_layers:
+            ll = vector(perimeter_margin, perimeter_margin)
+            ur = vector(self.width - perimeter_margin, self.height - perimeter_margin)
+            self.blockages[layer_name].append(pin_layout("",
+                                                         [ll, ur],
+                                                         layer_name))
+
+        # For each pin, remove the blockage and add the pin
+        for pin_name in self.pins:
+            pin = self.get_pin(pin_name)
+            inflated_pin = pin.inflated_pin(multiple=1)
+            for blockage in self.blockages[pin.layer]:
+                if blockage.overlaps(inflated_pin):
+                    intersection_shape = blockage.intersection(inflated_pin)
+                    # If it is zero area, don't add the pin
+                    if intersection_shape[0][0]==intersection_shape[1][0] or intersection_shape[0][1]==intersection_shape[1][1]:
+                        continue
+                    # Remove the old blockage and add the new ones
+                    self.blockages[pin.layer].remove(blockage)
+                    intersection_pin = pin_layout("", intersection_shape, inflated_pin.layer)
+                    new_blockages = blockage.cut(intersection_pin)
+                    self.blockages[pin.layer].extend(new_blockages)
+
+            self.lef_write_pin(pin_name)
+
+        self.lef_write_obstructions(abstracted=True)
+        self.lef_write_footer()
+        self.lef.close()
+
+    def detailed_lef_write(self, lef_name):
+        # To maintain the indent level easily
+        self.indent = ""
 
         self.lef  = open(lef_name, "w")
         self.lef_write_header()
@@ -136,24 +188,29 @@ class lef:
         self.indent = self.indent[:-3]
         self.lef.write("{0}END {1}\n".format(self.indent, name))
 
-    def lef_write_obstructions(self):
+    def lef_write_obstructions(self, abstracted=False):
         """ Write all the obstructions on each layer """
         self.lef.write("{0}OBS\n".format(self.indent))
         for layer in self.lef_layers:
             self.lef.write("{0}LAYER  {1} ;\n".format(self.indent, layer_names[layer]))
             self.indent += "   "
-            blockages = self.get_blockages(layer, True)
-            for b in blockages:
-                self.lef_write_shape(b)
+            if abstracted:
+                blockages = self.blockages[layer]
+                for b in blockages:
+                    self.lef_write_shape(b.rect)
+            else:
+                blockages = self.get_blockages(layer, True)
+                for b in blockages:
+                    self.lef_write_shape(b)
             self.indent = self.indent[:-3]
         self.lef.write("{0}END\n".format(self.indent))
 
-    def lef_write_shape(self, rect):
-        if len(rect) == 2:
+    def lef_write_shape(self, obj):
+        if len(obj) == 2:
             """ Write a LEF rectangle """
             self.lef.write("{0}RECT ".format(self.indent))
-            for item in rect:
-                # print(rect)
+            for item in obj:
+                # print(obj)
                 self.lef.write(" {0} {1}".format(round(item[0],
                                                        self.round_grid),
                                                  round(item[1],
@@ -162,12 +219,10 @@ class lef:
         else:
             """ Write a LEF polygon """
             self.lef.write("{0}POLYGON ".format(self.indent))
-            for item in rect:
+            for item in obj:
                 self.lef.write(" {0} {1}".format(round(item[0],
                                                        self.round_grid),
                                                  round(item[1],
                                                        self.round_grid)))
-            # for i in range(0,len(rect)):
-                # self.lef.write(" {0} {1}".format(round(rect[i][0],self.round_grid), round(rect[i][1],self.round_grid)))
             self.lef.write(" ;\n")