Programmatic LayoutToNetlist with "flat" mode

Comments

• Matthias

  August 22

  Hi @Tabra,

  first of all, DRC is build upon Ruby, which is essentially pya, but in Ruby binding. There is no disadvantage of Ruby vs. Python. All DRC features are routed to corresponding API calls, so simply translating them to pya would give you the implementation. Specifically, I don't understand, why "input" should be slow compared to loading a layout into the UI.

  The DRC implementation is here: https://github.com/KLayout/klayout/tree/master/src/drc/drc/built-in-macros.

  Regarding your questions:
  1.) For a flat netlist extraction, instantiate the LayoutToNetlist with cell name and DBU value (https://www.klayout.de/doc-qt5/code/class_LayoutToNetlist.html#method87).
  2.) LayoutToNetlist is much different from the net tracer feature, which is kind of legacy. So the interfaces won't fit. There is no direct bridge. The net tracer UI emulates the old net tracers connectivity and configures LayoutToNetlist correspondingly in 'trace all nets' mode. But that code is not available to pya.

  Matthias
• Tabra

  August 25

  Hi @Matthias,

  Thank you for addressing my request.

  • Correct me if I'm wrong, but the function you have pointed me to for flat netlist extraction is the one which has as parameters a cell name string and the dbu, and that could not filter sub-cells afaik, unless it can be done post function call(?)

  And after looking through the DRC code, I found out that the netlist browser opening is performed when finishing the DRC script, and not with an explicit command. Using the following code works:

  lv = pya.Application.instance().main_window().current_view()
  l2nIdx = lv.replace_l2ndb( lv.create_l2ndb("netlist_name"), l2n )
  lv.show_l2ndb(l2nIdx,0)
  

  Btw I wrote a pya implementation to load the technology connectivity into l2n. Feel free to take it if you'd like:

  def loadTechConnect(ly, l2n, techName, stackName):
  
    tech = pya.Technology().technology_by_name(techName).component("connectivity")
    conList = [] # Each pair in this list is a new connection
  
    for iStack in tech.each():
  
      if iStack.name != stackName:
        continue
  
      # Make list of connections
      for iCon in iStack.each_connection():
  
        a = iCon.layer_a()
        b = iCon.layer_b()
        v = iCon.via_layer()
  
        if (a == "" or b == ""):
          raise Exception("Connectivity not properly defined. Fix technology setup.")
  
        # Add pairs of layers (order of pair doesn't matter)
        conList.append(a)
        if v != "":
          conList.append(v)
          conList.append(v)
        conList.append(b)
  
      # Replace symbols, if applies
      for iSym in iStack.each_symbol():
  
        sym = iSym.symbol()
        expr = iSym.expression()
  
        for i in range(len(conList)):
          if conList[i] == sym:
            conList[i] = expr
  
      uniConList = list(set(conList))
      conDict = {}
  
      # Generate dictionary with layerInfo associations
      for iLayer in uniConList:
  
        [a,b] = iLayer.split("/")
        layerStruct = l2n.make_layer( ly.layer(int(a),int(b)) )
        conDict.update({iLayer: layerStruct})
  
        # Use the loop to also intra-connect layers once
        l2n.connect(conDict[iLayer])
  
      for i in range(int(len(conList)/2)):
        l2n.connect(conDict[conList[2*i]],conDict[conList[2*i+1]])
  
    return l2n
  

  Funny enough, using the function you mentioned gives the error:
  RuntimeError: Internal error: deep shape store isn't singular. This may happen if you try to mix hierarchical layers from different sources our you use clipping. in LayoutToNetlist.make_polygon_layer
  But it works by using the usual RecursiveShapeIterator

  Thank you very much again Matthias.

  Gerard
• Tabra

  August 25

  Non-ideal at all and slow, but here's a working solution:

  def flattenLayout(ly, filterList):
  
    ly = ly.dup()
  
    # Apply filters
    for iFilt in filterList:
      for iCell in ly.cells(iFilt):
        if not(iCell.destroyed()):
          ly.delete_cell_rec(iCell.cell_index())
  
    # Flatten remaining cells
    for i in ly.each_top_cell():
      ly.flatten(i,-1,1)
  
    return ly
  
• Matthias

  August 25

  Hi @Tabra,

  Thanks for the connectivity tracer tech stack conversion. This code is pretty much the same thing that the net tracer does internally. I still don't think that the net tracer stack description is a good one given the much more evolved capabilities of LayoutToNetlist, but if you're happy with that - it's your choice.

  You should be able to do cell selection by manipulating the RecursiveShapeIterator you feed the shapes with. It has 'select_cells' and 'unselect_cells' to make it not deliver subtrees. See here for details: https://www.klayout.de/doc-qt5/code/class_RecursiveShapeIterator.html

  But when do you get the internal error you mentioned?

  Matthias
• Tabra

  August 27

  Hi @Matthias,

  My take on using Technologies is that these are a convenient way to set up and select rules/connectivities all from the UI without the need of handling code. And more importantly, this kind of details makes the software more self-integrated and powerful, even if only apparent from the surface as there are still 2 netlist systems (maybe to be united in the future?).

  Anyways, I found the ultimate solution. Turns out you CAN flatten the circuits post extraction with l2n.netlist().flatten(), and that's the best way I found WHILE allowing for filtering. Time-wise it's as fast as using UI's Trace All Nets, so it doesn't get any better than that.

  filterList = ["...*",...]
  
  lv = pya.Application.instance().main_window().current_view()
  ly = lv.active_cellview().layout()
  
  iter = pya.RecursiveShapeIterator(ly, ly.top_cell(), [])
  for iFilter in filterList:
    iter.unselect_cells(iFilt)
  l2n = pya.LayoutToNetlist(iter)
  
  l2n = loadTechConnectivity(ly, l2n, "", "")
  l2n.include_floating_subcircuits=(True)
  l2n.extract_netlist()
  l2n.netlist().flatten()
  
  l2nIdx = lv.replace_l2ndb( lv.create_l2ndb(ly.top_cell().name + " netlist"), l2n )
    lv.show_l2ndb(l2nIdx,0)
  

  Although I'll modify it a bit to name the nets after the parent subcircuit + text points found over the net. I'm aware that running an LVS does kind of that, but I can't get it to work and maybe more control over the code solves it (not blackboxing my way)

  Thank you for forcing me to look for the answer myself haha.

  Bests,
  Gerard