klayout/testdata/python/dbPCells.py

# KLayout Layout Viewer
# Copyright (C) 2006-2025 Matthias Koefferlein
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


import pya
import unittest
import math
import sys

class BoxPCell(pya.PCellDeclaration):

  def display_text(self, parameters):
    # provide a descriptive text for the cell
    return "Box(L=" + str(parameters[0]) + ",W=" + ('%.3f' % parameters[1]) + ",H=" + ('%.3f' % parameters[2]) + ")"
  
  def get_parameters(self):
  
    # prepare a set of parameter declarations
    param = []
    
    param.append(pya.PCellParameterDeclaration("l", pya.PCellParameterDeclaration.TypeLayer, "Layer", pya.LayerInfo(0, 0)))
    param.append(pya.PCellParameterDeclaration("w", pya.PCellParameterDeclaration.TypeDouble, "Width", 1.0))
    param.append(pya.PCellParameterDeclaration("h", pya.PCellParameterDeclaration.TypeDouble, "Height", 1.0))
    
    return param
    

  def get_layers(self, parameters):
    return [ parameters[0] ]
  
  def produce(self, layout, layers, parameters, cell):
  
    dbu = layout.dbu

    # fetch the parameters
    l = parameters[0]
    w = parameters[1] / layout.dbu
    h = parameters[2] / layout.dbu
    
    # create the shape
    cell.shapes(layers[0]).insert(pya.Box(-w / 2, -h / 2, w / 2, h / 2))

  def can_create_from_shape(self, layout, shape, layer):
    return shape.is_box()

  def transformation_from_shape(self, layout, shape, layer):
    return pya.Trans(shape.box.center() - pya.Point())

  def parameters_from_shape(self, layout, shape, layer):
    return [ layout.get_info(layer), shape.box.width() * layout.dbu, shape.box.height() * layout.dbu ]
    
class PCellTestLib(pya.Library):

  def __init__(self):  
  
    # set the description
    self.description = "PCell test lib"
    
    # create the PCell declarations
    self.layout().register_pcell("Box", BoxPCell())

    sb_index = self.layout().add_cell("StaticBox")
    l10 = self.layout().insert_layer(pya.LayerInfo(10, 0))
    sb_cell = self.layout().cell(sb_index)
    sb_cell.shapes(l10).insert(pya.Box(0, 0, 100, 200))
    
    # register us with the name "PCellTestLib"
    self.register("PCellTestLib")


if "PCellDeclarationHelper" in pya.__dict__:

  # A PCell based on the declaration helper

  class BoxPCell2(pya.PCellDeclarationHelper):

    def __init__(self):

      super(BoxPCell2, self).__init__()
    
      self.param("layer", self.TypeLayer, "Layer", default = pya.LayerInfo(0, 0))
      self.param("width", self.TypeDouble, "Width", default = 1.0)
      self.param("height", self.TypeDouble, "Height", default = 1.0)
      
    def display_text_impl(self):
      # provide a descriptive text for the cell
      return "Box2(L=" + str(self.layer) + ",W=" + ('%.3f' % self.width) + ",H=" + ('%.3f' % self.height) + ")"
    
    def wants_lazy_evaluation(self):
      return True

    def produce_impl(self):
    
      dbu = self.layout.dbu

      # fetch the parameters
      l = self.layer_layer
      w = self.width / self.layout.dbu
      h = self.height / self.layout.dbu
      
      # create the shape
      self.cell.shapes(l).insert(pya.Box(-w / 2, -h / 2, w / 2, h / 2))
      
    def can_create_from_shape_impl(self):
      return self.shape.is_box()

    def transformation_from_shape_impl(self):
      return pya.Trans(self.shape.box.center() - pya.Point())

    def parameters_from_shape_impl(self):
      self.layer = self.layout.get_info(self.layer)
      self.width = self.shape.box.width() * self.layout.dbu
      self.height = self.shape.box.height() * self.layout.dbu
      
  class PCellTestLib2(pya.Library):

    def __init__(self):  
    
      # set the description
      self.description = "PCell test lib2"
      
      # create the PCell declarations
      self.layout().register_pcell("Box2", BoxPCell2())

      # register us with the name "PCellTestLib2"
      self.register("PCellTestLib2")

  # A recursive PCell

  class RecursivePCell(pya.PCellDeclarationHelper):

    def __init__(self):

      super(RecursivePCell, self).__init__()
    
      self.param("layer", self.TypeLayer, "Layer", default = pya.LayerInfo(0, 0))
      self.param("line", self.TypeShape, "Line", default = pya.Edge(0, 0, 10000, 0))
      self.param("level", self.TypeInt, "Level", default = 1)
      
    def display_text_impl(self):
      # provide a descriptive text for the cell
      return "RecursivePCell(L=" + str(self.layer) + ",E=" + str(pya.CplxTrans(self.layout.dbu) * self.line) + ",LVL=" + str(self.level)
    
    def produce_impl(self):
    
      # fetch the parameters
      l = self.layer_layer
      e = self.line

      if self.level <= 0:
        self.cell.shapes(l).insert(e)
        return

      d3 = e.d() * (1.0 / 3.0)
      d3n = pya.Vector(-d3.y, d3.x)

      e1 = pya.Edge(e.p1, e.p1 + d3)
      e2 = pya.Edge(e1.p2, e1.p2 + d3 * 0.5 + d3n * math.cos(math.pi / 6))
      e3 = pya.Edge(e2.p2, e.p1 + d3 * 2.0)
      e4 = pya.Edge(e3.p2, e.p2)

      for e in [ e1, e2, e3, e4 ]:
        t = pya.Trans(e.p1 - pya.Point())
        cc = self.layout.create_cell("RecursivePCell", { "layer": self.layer, "line": t.inverted() * e, "level": self.level - 1 })
        self.cell.insert(pya.CellInstArray(cc, t))
      
  class PCellTestLib3(pya.Library):

    def __init__(self):  
    
      # set the description
      self.description = "PCell test lib3"
      
      # create the PCell declarations
      self.layout().register_pcell("RecursivePCell", RecursivePCell())

      # register us with the name "PCellTestLib3"
      self.register("PCellTestLib3")



def inspect_LayerInfo(self):
    return "<" + str(self) + ">"

pya.LayerInfo.__repr__ = inspect_LayerInfo

def find_layer(ly, lp):

  for li in ly.layer_indices():
    if str(ly.get_info(li)) == lp:
      return li
  return None


def nh(h):
  """
  Returns a normalized hash representation
  """
  v = []
  for k in sorted(h):
    v.append(repr(k) + ": " + repr(h[k]))
  return "{" + (", ".join(v)) + "}"

class DBPCellTests(unittest.TestCase):

  def test_0(self):

    # PCellDeclarationHelper is inside "pya.__all__"
    if hasattr(pya, "__all__"):
      self.assertEqual("PCellDeclarationHelper" in pya.__all__, True)

  def test_1(self):

    # instantiate and register the library
    tl = PCellTestLib()

    ly = pya.Layout(True)
    ly.dbu = 0.01

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 == None, True)

    ci1 = ly.add_cell("c1")
    c1 = ly.cell(ci1)

    lib = pya.Library.library_by_name("NoLib")
    self.assertEqual(lib == None, True)
    lib = pya.Library.library_by_name("PCellTestLib")
    self.assertEqual(lib != None, True)
    pcell_decl = lib.layout().pcell_declaration("x")
    self.assertEqual(pcell_decl == None, True)
    pcell_decl = lib.layout().pcell_declaration("Box")
    self.assertEqual(pcell_decl != None, True)
    pcell_decl_id = lib.layout().pcell_id("Box")
    self.assertEqual(pcell_decl.id(), pcell_decl_id)
    self.assertEqual(":".join(lib.layout().pcell_names()), "Box")
    self.assertEqual(lib.layout().pcell_ids(), [ pcell_decl_id ])
    self.assertEqual(lib.layout().pcell_declaration(pcell_decl_id).id(), pcell_decl_id)

    param = [ pya.LayerInfo(1, 0) ]  # rest is filled with defaults
    pcell_var_id = ly.add_pcell_variant(lib, pcell_decl_id, param)
    pcell_var = ly.cell(pcell_var_id)
    pcell_inst = c1.insert(pya.CellInstArray(pcell_var_id, pya.Trans()))
    self.assertEqual(pcell_var.layout().__repr__(), ly.__repr__())
    self.assertEqual(pcell_var.library().__repr__(), lib.__repr__())
    self.assertEqual(pcell_var.is_pcell_variant(), True)
    self.assertEqual(pcell_var.display_title(), "PCellTestLib.Box(L=1/0,W=1.000,H=1.000)")
    self.assertEqual(pcell_var.basic_name(), "Box")
    self.assertEqual(pcell_var.pcell_declaration().wants_lazy_evaluation(), False)
    self.assertEqual(c1.is_pcell_variant(), False)
    self.assertEqual(c1.is_pcell_variant(pcell_inst), True)
    self.assertEqual(pcell_var.pcell_id(), pcell_decl_id)
    self.assertEqual(pcell_var.pcell_library().__repr__(), lib.__repr__())
    self.assertEqual(pcell_var.pcell_parameters().__repr__(), "[<1/0>, 1.0, 1.0]")
    self.assertEqual(nh(pcell_var.pcell_parameters_by_name()), "{'h': 1.0, 'l': <1/0>, 'w': 1.0}")
    self.assertEqual(pcell_var.pcell_parameter("h").__repr__(), "1.0")
    self.assertEqual(c1.pcell_parameters(pcell_inst).__repr__(), "[<1/0>, 1.0, 1.0]")
    self.assertEqual(nh(c1.pcell_parameters_by_name(pcell_inst)), "{'h': 1.0, 'l': <1/0>, 'w': 1.0}")
    self.assertEqual(c1.pcell_parameter(pcell_inst, "h").__repr__(), "1.0")
    self.assertEqual(nh(pcell_inst.pcell_parameters_by_name()), "{'h': 1.0, 'l': <1/0>, 'w': 1.0}")
    self.assertEqual(pcell_inst["h"].__repr__(), "1.0")
    self.assertEqual(pcell_inst["i"].__repr__(), "None")
    self.assertEqual(pcell_inst.pcell_parameter("h").__repr__(), "1.0")
    self.assertEqual(pcell_var.pcell_declaration().__repr__(), pcell_decl.__repr__())
    self.assertEqual(c1.pcell_declaration(pcell_inst).__repr__(), pcell_decl.__repr__())
    self.assertEqual(pcell_inst.pcell_declaration().__repr__(), pcell_decl.__repr__())

    pcell_inst.change_pcell_parameter("h", 2.0)
    self.assertEqual(nh(pcell_inst.pcell_parameters_by_name()), "{'h': 2.0, 'l': <1/0>, 'w': 1.0}")
    pcell_inst.set_property("abc", "a property")
    self.assertEqual(pcell_inst.property("abc").__repr__(), "'a property'")

    c1.clear()

    param = [ pya.LayerInfo(1, 0), 5.0, 10.0 ]
    pcell_var_id = ly.add_pcell_variant(lib, pcell_decl_id, param)
    pcell_var = ly.cell(pcell_var_id)
    pcell_inst = c1.insert(pya.CellInstArray(pcell_var_id, pya.Trans()))
    self.assertEqual(pcell_var.layout().__repr__(), ly.__repr__())
    self.assertEqual(pcell_var.library().__repr__(), lib.__repr__())
    self.assertEqual(pcell_var.is_pcell_variant(), True)
    self.assertEqual(pcell_var.display_title(), "PCellTestLib.Box(L=1/0,W=5.000,H=10.000)")
    self.assertEqual(pcell_var.basic_name(), "Box")
    self.assertEqual(c1.is_pcell_variant(), False)
    self.assertEqual(c1.is_pcell_variant(pcell_inst), True)
    self.assertEqual(pcell_var.pcell_id(), pcell_decl_id)
    self.assertEqual(pcell_var.pcell_library().__repr__(), lib.__repr__())
    self.assertEqual(pcell_var.pcell_parameters().__repr__(), "[<1/0>, 5.0, 10.0]")
    self.assertEqual(c1.pcell_parameters(pcell_inst).__repr__(), "[<1/0>, 5.0, 10.0]")
    self.assertEqual(pcell_inst.pcell_parameters().__repr__(), "[<1/0>, 5.0, 10.0]")
    self.assertEqual(pcell_var.pcell_declaration().__repr__(), pcell_decl.__repr__())
    self.assertEqual(c1.pcell_declaration(pcell_inst).__repr__(), pcell_decl.__repr__())

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 != None, True)
    self.assertEqual(ly.is_valid_layer(li1), True)
    self.assertEqual(str(ly.get_info(li1)), "1/0")

    lib_proxy_id = ly.add_lib_cell(lib, lib.layout().cell_by_name("StaticBox"))
    lib_proxy = ly.cell(lib_proxy_id)
    self.assertEqual(lib_proxy.display_title(), "PCellTestLib.StaticBox")
    self.assertEqual(lib_proxy.basic_name(), "StaticBox")
    self.assertEqual(lib_proxy.layout().__repr__(), ly.__repr__())
    self.assertEqual(lib_proxy.library().__repr__(), lib.__repr__())
    self.assertEqual(lib_proxy.is_pcell_variant(), False)
    self.assertEqual(lib.layout().cell(lib.layout().cell_by_name("StaticBox")).library().__repr__(), "None")

    li2 = find_layer(ly, "10/0")
    self.assertEqual(li2 != None, True)

    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-250,-500;250,500)")
    self.assertEqual(ly.begin_shapes(lib_proxy.cell_index(), li2).shape().__str__(), "box (0,0;10,20)")

    param = { "w": 1, "h": 2 }
    c1.change_pcell_parameters(pcell_inst, param)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-50,-100;50,100)")
    
    param = [ pya.LayerInfo(1, 0), 5.0, 5.0 ]
    c1.change_pcell_parameters(pcell_inst, param)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-250,-250;250,250)")
    
    pcell_inst.change_pcell_parameters({ "w": 2.0, "h": 10.0 })
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-100,-500;100,500)")

    pcell_inst.change_pcell_parameters([ pya.LayerInfo(1, 0), 5.0, 5.0 ])
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-250,-250;250,250)")

    pcell_inst.change_pcell_parameter("w", 5.0)
    pcell_inst.change_pcell_parameter("h", 1.0)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-250,-50;250,50)")

    c1.change_pcell_parameter(pcell_inst, "w", 10.0)
    c1.change_pcell_parameter(pcell_inst, "h", 2.0)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-500,-100;500,100)")

    self.assertEqual(ly.cell(pcell_inst.cell_index).is_pcell_variant(), True)
    self.assertEqual(pcell_inst.is_pcell(), True)
    new_id = ly.convert_cell_to_static(pcell_inst.cell_index)
    self.assertEqual(new_id == pcell_inst.cell_index, False)
    self.assertEqual(ly.cell(new_id).is_pcell_variant(), False)
    param = [ pya.LayerInfo(1, 0), 5.0, 5.0 ]
    c1.change_pcell_parameters(pcell_inst, param)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-250,-250;250,250)")
    pcell_inst.cell_index = new_id
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-500,-100;500,100)")

    l10 = ly.layer(10, 0)
    c1.shapes(l10).insert(pya.Box(0, 10, 100, 210))
    l11 = ly.layer(11, 0)
    c1.shapes(l11).insert(pya.Text("hello", pya.Trans()))
    self.assertEqual(pcell_decl.can_create_from_shape(ly, ly.begin_shapes(c1.cell_index(), l11).shape(), l10), False)
    self.assertEqual(pcell_decl.can_create_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10), True)
    self.assertEqual(repr(pcell_decl.parameters_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10)), "[<10/0>, 1.0, 2.0]")
    self.assertEqual(str(pcell_decl.transformation_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10)), "r0 50,110")


  def test_1a(self):

    if not "PCellDeclarationHelper" in pya.__dict__:
      return

    # instantiate and register the library
    tl = PCellTestLib2()

    ly = pya.Layout(True)
    ly.dbu = 0.01

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 == None, True)

    ci1 = ly.add_cell("c1")
    c1 = ly.cell(ci1)

    lib = pya.Library.library_by_name("PCellTestLib2")
    self.assertEqual(lib != None, True)
    pcell_decl = lib.layout().pcell_declaration("Box2")

    param = [ pya.LayerInfo(1, 0) ]  # rest is filled with defaults
    pcell_var_id = ly.add_pcell_variant(lib, pcell_decl.id(), param)
    pcell_var = ly.cell(pcell_var_id)
    pcell_inst = c1.insert(pya.CellInstArray(pcell_var_id, pya.Trans()))
    self.assertEqual(pcell_var.basic_name(), "Box2")
    self.assertEqual(pcell_var.pcell_parameters().__repr__(), "[<1/0>, 1.0, 1.0]")
    self.assertEqual(pcell_var.display_title(), "PCellTestLib2.Box2(L=1/0,W=1.000,H=1.000)")
    self.assertEqual(nh(pcell_var.pcell_parameters_by_name()), "{'height': 1.0, 'layer': <1/0>, 'width': 1.0}")
    self.assertEqual(pcell_var.pcell_parameter("height").__repr__(), "1.0")
    self.assertEqual(c1.pcell_parameters(pcell_inst).__repr__(), "[<1/0>, 1.0, 1.0]")
    self.assertEqual(nh(c1.pcell_parameters_by_name(pcell_inst)), "{'height': 1.0, 'layer': <1/0>, 'width': 1.0}")
    self.assertEqual(c1.pcell_parameter(pcell_inst, "height").__repr__(), "1.0")
    self.assertEqual(nh(pcell_inst.pcell_parameters_by_name()), "{'height': 1.0, 'layer': <1/0>, 'width': 1.0}")
    self.assertEqual(pcell_inst["height"].__repr__(), "1.0")
    self.assertEqual(pcell_inst.pcell_parameter("height").__repr__(), "1.0")
    self.assertEqual(pcell_var.pcell_declaration().__repr__(), pcell_decl.__repr__())
    self.assertEqual(c1.pcell_declaration(pcell_inst).__repr__(), pcell_decl.__repr__())
    self.assertEqual(pcell_inst.pcell_declaration().__repr__(), pcell_decl.__repr__())
    self.assertEqual(pcell_decl.wants_lazy_evaluation(), True)

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 == None, False)
    pcell_inst.change_pcell_parameter("height", 2.0)
    self.assertEqual(nh(pcell_inst.pcell_parameters_by_name()), "{'height': 2.0, 'layer': <1/0>, 'width': 1.0}")

    self.assertEqual(ly.begin_shapes(c1.cell_index(), li1).shape().__str__(), "box (-50,-100;50,100)")

    param = { "layer": pya.LayerInfo(2, 0), "width": 2, "height": 1 }
    li2 = ly.layer(2, 0)
    c1.change_pcell_parameters(pcell_inst, param)
    self.assertEqual(ly.begin_shapes(c1.cell_index(), li2).shape().__str__(), "box (-100,-50;100,50)")

    l10 = ly.layer(10, 0)
    c1.shapes(l10).insert(pya.Box(0, 10, 100, 210))
    l11 = ly.layer(11, 0)
    c1.shapes(l11).insert(pya.Text("hello", pya.Trans()))
    self.assertEqual(pcell_decl.can_create_from_shape(ly, ly.begin_shapes(c1.cell_index(), l11).shape(), l10), False)
    self.assertEqual(pcell_decl.can_create_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10), True)
    self.assertEqual(repr(pcell_decl.parameters_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10)), "[<10/0>, 1.0, 2.0]")
    self.assertEqual(str(pcell_decl.transformation_from_shape(ly, ly.begin_shapes(c1.cell_index(), l10).shape(), l10)), "r0 50,110")


  def test_2(self):

    # instantiate and register the library
    tl = PCellTestLib()

    ly = pya.Layout(True)
    ly.dbu = 0.01

    ci1 = ly.add_cell("c1")
    c1 = ly.cell(ci1)

    lib = pya.Library.library_by_name("PCellTestLib")
    pcell_decl_id = lib.layout().pcell_id("Box")

    param = [ pya.LayerInfo(1, 0), 10.0, 2.0 ]
    pcell_var_id = ly.add_pcell_variant(lib, pcell_decl_id, param)
    pcell_var = ly.cell(pcell_var_id)
    pcell_inst = c1.insert(pya.CellInstArray(pcell_var_id, pya.Trans()))

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 != None, True)
    self.assertEqual(ly.is_valid_layer(li1), True)
    self.assertEqual(str(ly.get_info(li1)), "1/0")

    self.assertEqual(pcell_inst.is_pcell(), True)

    self.assertEqual(ly.begin_shapes(pcell_inst.cell_index, li1).shape().__str__(), "box (-500,-100;500,100)")
    pcell_inst.convert_to_static()
    self.assertEqual(pcell_inst.is_pcell(), False)
    self.assertEqual(ly.begin_shapes(pcell_inst.cell_index, li1).shape().__str__(), "box (-500,-100;500,100)")
    pcell_inst.convert_to_static()
    self.assertEqual(pcell_inst.is_pcell(), False)
    self.assertEqual(ly.begin_shapes(pcell_inst.cell_index, li1).shape().__str__(), "box (-500,-100;500,100)")

  def test_3(self):

    # instantiate and register the library
    tl = PCellTestLib()

    ly = pya.Layout(True)
    ly.dbu = 0.01

    c1 = ly.create_cell("c1")

    lib = pya.Library.library_by_name("PCellTestLib")
    pcell_decl_id = lib.layout().pcell_id("Box")

    param = { "w": 4.0, "h": 8.0, "l": pya.LayerInfo(1, 0) }
    pcell_var_id = ly.add_pcell_variant(lib, pcell_decl_id, param)
    pcell_var = ly.cell(pcell_var_id)
    pcell_inst = c1.insert(pya.CellInstArray(pcell_var_id, pya.Trans()))

    self.assertEqual(ly.begin_shapes(c1.cell_index(), ly.layer(1, 0)).shape().__str__(), "box (-200,-400;200,400)")
      
  def test_4(self):

    # instantiate and register the library
    tl = PCellTestLib()

    lib = pya.Library.library_by_name("PCellTestLib")
    pcell_decl_id = lib.layout().pcell_id("Box")

    param = { "w": 4.0, "h": 8.0, "l": pya.LayerInfo(1, 0) }
    pcell_var_id = lib.layout().add_pcell_variant(pcell_decl_id, param)

    self.assertEqual(lib.layout().begin_shapes(pcell_var_id, lib.layout().layer(1, 0)).shape().__str__(), "box (-2000,-4000;2000,4000)")
    
  def test_5(self):

    # instantiate and register the library
    tl = PCellTestLib()

    lib = pya.Library.library_by_name("PCellTestLib")
    pcell_decl_id = lib.layout().pcell_id("Box")

    param = { "w": 3.0, "h": 7.0, "l": pya.LayerInfo(2, 0) }
    pcell_var_id = lib.layout().add_pcell_variant(pcell_decl_id, param)

    self.assertEqual(lib.layout().begin_shapes(pcell_var_id, lib.layout().layer(2, 0)).shape().__str__(), "box (-1500,-3500;1500,3500)")
    

  def test_6(self):

    # instantiate and register the library
    tl = PCellTestLib()

    lib = pya.Library.library_by_name("PCellTestLib")

    param = { "w": 3.0, "h": 8.0, "l": pya.LayerInfo(3, 0) }
    pcell_var = lib.layout().create_cell("Box", param)

    self.assertEqual(lib.layout().begin_shapes(pcell_var.cell_index(), lib.layout().layer(3, 0)).shape().__str__(), "box (-1500,-4000;1500,4000)")
    

  def test_7(self):

    # instantiate and register the library
    tl = PCellTestLib()

    ly = pya.Layout(True)
    ly.dbu = 0.01

    param = { "w": 4.0, "h": 8.0, "l": pya.LayerInfo(4, 0) }
    cell = ly.create_cell("Box", "PCellTestLib", param)

    self.assertEqual(ly.begin_shapes(cell, ly.layer(4, 0)).shape().__str__(), "box (-200,-400;200,400)")

  def test_8(self):

    # instantiate and register the library
    tl = PCellTestLib()

    lib = pya.Library.library_by_name("PCellTestLib")
    ly = pya.Layout(True)
    ly.dbu = 0.01

    param = { "w": 2.0, "h": 6.0, "l": pya.LayerInfo(5, 0) }
    pcell_var = lib.layout().create_cell("Box", param)
    pcell_var.name = "BOXVAR"

    cell = ly.create_cell("BOXVAR", "PCellTestLib")

    self.assertEqual(cell.begin_shapes_rec(ly.layer(5, 0)).shape().__str__(), "box (-100,-300;100,300)")

  def test_9(self):

    if not "PCellDeclarationHelper" in pya.__dict__:
      return

    # instantiate and register the library
    tl = PCellTestLib3()

    ly = pya.Layout(True)

    li1 = find_layer(ly, "1/0")
    self.assertEqual(li1 == None, True)

    c1 = ly.create_cell("c1")

    c2 = ly.create_cell("RecursivePCell", "PCellTestLib3", { "layer": pya.LayerInfo(1, 0), "level": 4, "line": pya.Edge(0, 0, 20000, 0) })
    c1.insert(pya.CellInstArray(c2.cell_index(), pya.Trans()))

    self.assertEqual(c2.display_title(), "PCellTestLib3.RecursivePCell(L=1/0,E=(0,0;20,0),LVL=4")
    self.assertEqual(str(c1.dbbox()), "(0,0;20,5.774)")

# run unit tests
if __name__ == '__main__':
  suite = unittest.TestLoader().loadTestsFromTestCase(DBPCellTests)

  if not unittest.TextTestRunner(verbosity = 1).run(suite).wasSuccessful():
    sys.exit(1)