API Verification¶

def write_drc_deck_macro(
    rules: list[str],
    layers: dict[str, Layer] | None = None,
    name: str = "generic",
    filepath: PathType | None = None,
    shortcut: str = "Ctrl+Shift+D",
    mode: str = "tiled",
    threads: int = 4,
    tile_size: int = 500,
    tile_borders: int | None = None,
) -> str:
    """Write KLayout DRC macro.

    You can customize the shortcut to run the DRC macro from the Klayout GUI.

    Args:
        rules: list of rules.
        layers: layer definitions can be dict or dataclass.
        name: drc rule deck name.
        filepath: Optional macro path (defaults to .klayout/drc/name.lydrc).
        shortcut: to run macro from KLayout GUI.
        mode: tiled, default or deep (hierarchical).
        threads: number of threads.
        tile_size: in um for tile mode.
        tile_borders: sides for each. Defaults None to automatic.

    .. code::

        import gdsfactory as gf
        from gplugins.klayout.drc.write_drc import (
            write_drc_deck_macro,
            check_enclosing,
            check_width,
            check_space,
            check_separation,
            check_area,
            check_density,
        )
        from gdsfactory.gpdk import LAYER
        rules = [
            check_width(layer="WG", value=0.2),
            check_space(layer="WG", value=0.2),
            check_separation(layer1="HEATER", layer2="M1", value=1.0),
            check_enclosing(layer1="VIAC", layer2="M1", value=0.2),
            check_area(layer="WG", min_area_um2=0.05),
            check_density(
                layer="WG", layer_floorplan="FLOORPLAN", min_density=0.5, max_density=0.6
            ),
            check_not_inside(layer="VIAC", not_inside="NPP"),
        ]

        drc_check_deck = write_drc_deck_macro(rules=rules, layers=LAYER, mode="tiled")
        print(drc_check_deck)

    """
    if mode not in modes:
        raise ValueError(f"{mode!r} not in {modes}")

    script = get_drc_script_start(name=name, shortcut=shortcut)

    script += get_drc_script(
        rules=rules,
        layers=layers,
        threads=threads,
        tile_size=tile_size,
        tile_borders=tile_borders,
        mode=mode,
    )

    script += drc_script_end
    filepath = filepath or get_klayout_path() / "drc" / f"{name}.lydrc"
    filepath = pathlib.Path(filepath)
    dirpath = filepath.parent
    dirpath.mkdir(parents=True, exist_ok=True)
    filepath = pathlib.Path(filepath)
    filepath.write_text(script, encoding="UTF-8")
    print(f"Wrote DRC deck to {str(filepath)!r} with shortcut {shortcut!r}")
    return script

def check_width(value: float | int, layer: str, angle_limit: float = 90.0) -> str:
    """Min feature size.

    Args:
        value: width in um if float, dbu if int (nm).
        layer: layer name.
        angle_limit: angle limit in degrees.
    """
    category = "width"
    error = f"{layer} {category} {value}um"
    return (
        f"{layer}.{category}({value}, angle_limit({angle_limit}))"
        f".output({error!r}, {error!r})"
    )

def check_space(value: float | int, layer: str, angle_limit: float = 90.0) -> str:
    """Min Space between shapes of layer.

    Args:
        value: width in um if float, dbu if int (nm).
        layer: layer name.
        angle_limit: angle limit in degrees.
    """
    category = "space"
    error = f"{layer} {category} {value}um"
    return (
        f"{layer}.{category}({value}, angle_limit({angle_limit}))"
        f".output({error!r}, {error!r})"
    )

def check_separation(value: float | int, layer1: str, layer2: str) -> str:
    """Min space between different layers.

    Args:
        value: width in um if float, dbu if int (nm).
        layer1: layer name.
        layer2: layer name.
    """
    error = f"min {layer1} {layer2} separation {value}um"
    return f"{layer1}.separation({layer2}, {value}).output({error!r}, {error!r})"

def check_enclosing(
    value: float | int, layer1: str, layer2: str, angle_limit: float = 90.0
) -> str:
    """Checks if layer1 encloses (is bigger than) layer2 by value.

    Args:
        value: width in um if float, dbu if int (nm).
        layer1: layer name.
        layer2: layer name.
        angle_limit: angle limit in degrees.

    """
    error = f"{layer1} enclosing {layer2} by {value}um"
    return (
        f"{layer1}.enclosing({layer2}, angle_limit({angle_limit}), {value})"
        f".output({error!r}, {error!r})"
    )

def check_area(layer: str, min_area_um2: float | int = 2.0) -> str:
    """Return script for min area checking.

    Args:
        layer: layer name.
        min_area_um2: min area in um2. int if dbu, float if um.

    """
    return f"""

min_{layer}_a = {min_area_um2}.um2
r_{layer}_a = {layer}.with_area(0, min_{layer}_a)
r_{layer}_a.output("{layer.upper()}_A: {layer} area < min_{layer}_a um2")
"""

def check_density(
    layer: str = "metal1",
    layer_floorplan: str = "FLOORPLAN",
    min_density: float = 0.2,
    max_density: float = 0.8,
) -> str:
    """Return script to ensure density of layer is within min and max.

    based on https://github.com/klayoutmatthias/si4all

    """
    return f"""
min_density = {min_density}
max_density = {max_density}

area = {layer}.area
border_area = {layer_floorplan}.area
if border_area >= 1.dbu * 1.dbu

  r_min_dens = polygon_layer
  r_max_dens = polygon_layer

  dens = area / border_area

  if dens < min_density
    # copy border as min density marker
    r_min_dens = {layer_floorplan}
  end

  if dens > max_density
    # copy border as max density marker
    r_max_dens = {layer_floorplan}
  end

  r_min_dens.output("{layer}_Xa: {layer} density below threshold of {min_density}")
  r_max_dens.output("{layer}: {layer} density above threshold of {max_density}")

end

"""

def check_not_inside(
    layer: str, not_inside: str, size: int | float | None = None
) -> str:
    """Checks for that a layer is not inside another layer.

    Args:
        layer: layer name.
        not_inside: layer name.
        size: optional layer size in um if float, dbu if int (nm).
    """
    if size is None:
        error = f"{layer} not inside {not_inside}"
        return f"{layer}.not_inside({not_inside}).output({error!r}, {error!r})"
    else:
        error = f"{layer} sized by {size} not inside {not_inside}"
        script = f"{layer}_sized = {layer}.size({size})\n "
        script += f"{layer}.not_inside({not_inside}).output({error!r}, {error!r})"
        return script