Parametric Cells¶

@gf.cell(tags=["IHP", "bondpad"])
def CuPillarPad() -> gf.Component:
    """Returns CuPillarPad copper pillar pad (imported from GDS)."""
    c = gf.import_gds(PATH.gds / "CuPillarPad.gds")
    width = 45
    c.add_port(
        name="e1", center=(0, 0), width=width, orientation=180, layer="TopMetal2drawing"
    )
    c.add_port(
        name="e2", center=(0, 0), width=width, orientation=0, layer="TopMetal2drawing"
    )
    c.add_port(
        name="e3", center=(0, 0), width=width, orientation=90, layer="TopMetal2drawing"
    )
    c.add_port(
        name="e4", center=(0, 0), width=width, orientation=270, layer="TopMetal2drawing"
    )
    return c

@gf.cell(tags=["IHP", "container"])
def add_pads_top(
    component: ComponentSpec = "straight",
    port_names: Strs | None = None,
    cross_section: CrossSectionSpec = "metal_routing",
    pad_port_name: str = "e1",
    pad: ComponentSpec = CuPillarPad,
    bend: ComponentSpec = "wire_corner",
    straight_separation: float = 15.0,
    pad_pitch: float = 100.0,
    port_type: str = "electrical",
    allow_width_mismatch: bool = True,
    fanout_length: float | None = 80,
    route_width: float | list[float] | None = 0,
    **kwargs,
) -> Component:
    """Returns new component with ports connected top pads.

    Args:
        component: component spec to connect to.
        port_names: list of port names to connect to pads.
        cross_section: cross_section function.
        pad_port_name: pad port name.
        pad: pad function.
        bend: bend function.
        straight_separation: from edge to edge.
        pad_pitch: spacing between pads.
        port_type: port type.
        allow_width_mismatch: if True, allows width mismatch.
        fanout_length: length of the fanout.
        route_width: width of the route.
        kwargs: additional arguments.

    Example:
        ```python
        import gdsfactory as gf
        c = gf.c.nxn(
            xsize=600,
            ysize=200,
            north=2,
            south=3,
            wg_width=10,
            layer="M3",
            port_type="electrical",
        )
        cc = gf.routing.add_pads_top(component=c, port_names=("e1", "e4"), fanout_length=50)
        cc.plot()
        ```

    """
    return gf.routing.add_pads_top(
        component=component,
        port_names=port_names,
        cross_section=cross_section,
        pad_port_name=pad_port_name,
        pad=pad,
        bend=bend,
        straight_separation=straight_separation,
        pad_pitch=pad_pitch,
        port_type=port_type,
        allow_width_mismatch=allow_width_mismatch,
        fanout_length=fanout_length,
        route_width=route_width,
        **kwargs,
    )

@gf.cell(tags=["IHP", "waveguide", "bend"])
def bend_euler(
    radius: float | None = None,
    angle: float = 90,
    p: float = 0.5,
    width: float | None = None,
    cross_section: CrossSectionSpec = "strip",
    allow_min_radius_violation: bool = False,
) -> gf.Component:
    """Regular degree euler bend.

    Args:
        radius: in um. Defaults to cross_section_radius.
        angle: total angle of the curve.
        p: Proportion of the curve that is an Euler curve.
        width: width to use. Defaults to cross_section.width.
        cross_section: specification (CrossSection, string, CrossSectionFactory dict).
        allow_min_radius_violation: if True allows radius to be smaller than cross_section radius.
    """
    return gf.c.bend_euler(
        radius=radius,
        angle=angle,
        p=p,
        width=width,
        cross_section=cross_section,
        allow_min_radius_violation=allow_min_radius_violation,
        with_arc_floorplan=True,
        npoints=None,
        layer=None,
    )

@gf.cell(tags=["IHP", "wire", "bend"])
def bend_metal(
    radius: float | None = None,
    angle: float = 90,
    width: float | None = None,
    cross_section: CrossSectionSpec = "metal_routing",
) -> gf.Component:
    """Regular degree euler bend.

    Args:
        radius: None.
        angle: 90.
        width: None.
        cross_section: "metal_routing".
    """
    if radius is None:
        if width:
            xs = gf.get_cross_section(cross_section=cross_section, width=width)
        else:
            xs = gf.get_cross_section(cross_section=cross_section)
        radius = xs.radius or xs.width
    return gf.c.bend_circular(
        radius=radius,
        angle=angle,
        width=width,
        cross_section=cross_section,
        allow_min_radius_violation=True,
        npoints=None,
        layer=None,
    )

@gf.cell(tags=["IHP", "waveguide", "bend"])
def bend_s(
    size: Size = (11, 1.8),
    cross_section: CrossSectionSpec = "strip",
    width: float | None = None,
    allow_min_radius_violation: bool = False,
) -> gf.Component:
    """Return S bend with bezier curve.

    stores min_bend_radius property in self.info['min_bend_radius']
    min_bend_radius depends on height and length

    Args:
        size: in x and y direction.
        cross_section: spec.
        width: width of the waveguide. If None, it will use the width of the cross_section.
        allow_min_radius_violation: allows min radius violations.
    """
    return gf.c.bend_s(
        size=size,
        cross_section=cross_section,
        npoints=99,
        allow_min_radius_violation=allow_min_radius_violation,
        width=width,
    )

@gf.cell(tags=["IHP", "wire", "bend"])
def bend_s_metal(
    size: Size = (11, 1.8),
    cross_section: CrossSectionSpec = "metal_routing",
    width: float | None = None,
    allow_min_radius_violation: bool = True,
) -> gf.Component:
    """Return S bend with bezier curve.

    stores min_bend_radius property in self.info['min_bend_radius']
    min_bend_radius depends on height and length

    Args:
        size: in x and y direction.
        cross_section: spec.
        width: width of the waveguide. If None, it will use the width of the cross_section.
        allow_min_radius_violation: allows min radius violations.
    """
    return gf.c.bend_s(
        size=size,
        cross_section=cross_section,
        npoints=99,
        allow_min_radius_violation=allow_min_radius_violation,
        width=width,
    )

@gf.cell(schematic_function=bondpad_schematic, tags=["IHP", "bondpad"])
def bondpad(
    shape: Literal["octagon", "square", "circle"] = "octagon",
    diameter: float = 80.0,
    layer_top_metal: LayerSpec = "TopMetal2drawing",
    layer_top_metal_pin: LayerSpec = "TopMetal2pin",
    layer_passiv: LayerSpec = "Passivpillar",
    layer_dfpad: LayerSpec = "dfpaddrawing",
    bbox_offsets: tuple[float, ...] | None = (-2.1, 0),
    flip_chip: bool = False,
) -> gf.Component:
    """Create a bondpad for wire bonding or flip-chip connection.

    Args:
        shape: Shape of the top-metal bondpad ("octagon", "square", or "circle").
        diameter: Interpreted as across-flats for octagons / squares, and diameter for circles.
        layer_top_metal: Top metal layer.
        layer_passiv: Passivation-opening layer.
        layer_dfpad: Deep-fill or density-fill support layer.
        bbox_offsets: Per-layer expansion distances in micrometers, applied to the passivation and dfpad layers.
        flip_chip: If True, suppress passivation opening for flip-chip bumps.

    Returns:
        Component containing the complete bondpad stack.
    """

    c = gf.Component()
    d = float(diameter)

    # Add top metal layer
    if shape == "square":
        c.add_ref(
            gf.components.rectangle(size=(d, d), layer=layer_top_metal, centered=True)
        )

    elif shape == "octagon":
        pts = regular_octagon_points(d)
        c.add_polygon(points=pts, layer=layer_top_metal)

    elif shape == "circle":
        c.add_ref(gf.components.circle(radius=d / 2, layer=layer_top_metal))

    else:
        raise ValueError(f"Unknown shape: {shape}")

    # Add additional layers
    if flip_chip:
        # Skip passivation opening for flip-chip
        bbox_layers = (layer_dfpad,)
        bbox_offsets = (bbox_offsets or ())[1:]
    else:
        bbox_layers = (layer_passiv, layer_dfpad)

    for layer, offset in zip(bbox_layers, bbox_offsets or ()):
        new_d = d + float(offset * 2)

        if shape == "square":
            c.add_ref(
                gf.components.rectangle(size=(new_d, new_d), layer=layer, centered=True)
            )
        elif shape == "circle":
            c.add_ref(gf.components.circle(radius=new_d / 2, layer=layer))
        elif shape == "octagon":
            c.add_polygon(points=regular_octagon_points(new_d), layer=layer)

    # Add port
    c.add_port(
        name="pad",
        center=(0, 0),
        width=d,
        orientation=0,
        layer=layer_top_metal_pin,
        port_type="electrical",
    )

    # Add metadata
    c.info["shape"] = shape
    c.info["diameter"] = diameter
    c.info["top_metal"] = layer_top_metal

    return c

@gf.cell(tags=["IHP", "bondpad", "array"])
def bondpad_array(
    n_pads: int = 4,
    pad_pitch: float = 100.0,
    pad_diameter: float = 80.0,
    shape: Literal["octagon", "square", "circle"] = "octagon",
    layer_top_metal: LayerSpec = "TopMetal2drawing",
    layer_top_metal_pin: LayerSpec = "TopMetal2pin",
    layer_passiv: LayerSpec = "Passivpillar",
    layer_dfpad: LayerSpec = "dfpaddrawing",
    bbox_offsets: tuple[float, ...] | None = (-2.1, 0),
) -> Component:
    """Create an array of bondpads.

    Args:
        n_pads: Number of bondpads.
        pad_pitch: Pitch between bondpad centers in micrometers.
        pad_diameter: Diameter of each bondpad in micrometers.
        shape: Shape of the bondpads.
        layer_top_metal: Top metal layer for the bondpad.
        layer_passiv: Passivation layer.
        layer_dfpad: Deep fill pad layer.
        bbox_offsets: Offsets for each additional layer.

    Returns:
        Component with bondpad array.
    """
    c = Component()

    for i in range(n_pads):
        pad = bondpad(
            shape=shape,
            diameter=pad_diameter,
            layer_top_metal=layer_top_metal,
            layer_top_metal_pin=layer_top_metal_pin,
            layer_passiv=layer_passiv,
            layer_dfpad=layer_dfpad,
            bbox_offsets=bbox_offsets,
        )
        pad_ref = c.add_ref(pad)
        pad_ref.movex(i * pad_pitch)

        # Add port for each pad
        c.add_port(
            name=f"pad_{i + 1}",
            center=(i * pad_pitch, 0),
            width=pad_diameter,
            orientation=0,
            layer=pad.ports["pad"].layer,
            port_type="electrical",
        )

    c.info["n_pads"] = n_pads
    c.info["pad_pitch"] = pad_pitch
    c.info["pad_diameter"] = pad_diameter

    # TODO: Bondpad array VLSIR Metadata

    return c

@gf.cell
def branch_line_coupler(
    connection_length: float = 100,
    frequency: float = 10e9,
    signal_cross_section: CrossSectionSpec = "topmetal2_routing",
    ground_cross_section: CrossSectionSpec = "topmetal1_routing",
    Z0: float = 50,
    e_r: float = 4.1,
) -> gf.Component:
    """Returns a branch line coupler coplanar transmission line.

    Creates signal and ground lines for a branch line coupler.

    Args:
        connection_length: Length of the input line.
        frequency: Operating frequency (Hz).
        signal_cross_section: Cross-section for the signal line.
        ground_cross_section: Cross-section for the ground line.
        Z0: Target characteristic impedance (ohms).
        e_r: Relative permittivity of the substrate. Defaults to 4.1 for silicon dioxide.
    """
    wave_length = 3e8 / frequency * 1e6

    c = gf.Component()

    corner = gf.Component()

    # calculate the needed widths
    width_Z0 = _calculate_width_from_Z0(
        Z0=Z0,
        ground_cross_section=ground_cross_section,
        signal_cross_section=signal_cross_section,
        e_r=e_r,
    )
    width_Z0_sqrt2 = _calculate_width_from_Z0(
        Z0=Z0 / sqrt(2),
        ground_cross_section=ground_cross_section,
        signal_cross_section=signal_cross_section,
        e_r=e_r,
    )
    e_eff = _calculate_effective_dielectric_constant(
        signal_cross_section=signal_cross_section,
        ground_cross_section=ground_cross_section,
        e_r=e_r,
    )

    quater_wave_length = wave_length / 4 / sqrt(e_eff)
    quater_wave_length = quater_wave_length - quater_wave_length % (
        tech.nm
    )  # truncate to 5 nm

    # create corner component for the 4 corners of the coupler
    corner.add_polygon(
        points=[
            (0, 0),
            (0, width_Z0),
            (width_Z0 - (width_Z0_sqrt2 - width_Z0), width_Z0),
            (width_Z0, width_Z0_sqrt2),
            (width_Z0, 0),
        ],
        layer=gf.get_cross_section(signal_cross_section).layer,
    )
    corner.add_port(
        name="e1",
        center=(width_Z0 / 2, 0),
        width=width_Z0,
        orientation=270,
        port_type="electrical",
        layer=gf.get_cross_section(signal_cross_section).layer,
    )
    corner.add_port(
        name="e2",
        center=(width_Z0, width_Z0_sqrt2 / 2),
        width=width_Z0_sqrt2,
        orientation=0,
        port_type="electrical",
        layer=gf.get_cross_section(signal_cross_section).layer,
    )
    corner.add_port(
        name="e3",
        center=(0, width_Z0 / 2),
        width=width_Z0,
        orientation=180,
        port_type="electrical",
        layer=gf.get_cross_section(signal_cross_section).layer,
    )

    # start with the top left corner
    corner_nw = c.add_ref(corner)

    # create and connect the top Z0/sqrt(2) transmission line
    tline_top = c.add_ref(
        tline(
            length=quater_wave_length - width_Z0,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0_sqrt2,
        )
    )

    tline_top.connect("e1", corner_nw.ports["e2"])

    # create and connect the top right corner
    corner_ne = c.add_ref(corner).mirror(p1=(0, 0), p2=(0, 1))

    corner_ne.connect("e2", tline_top.ports["e2"])

    # create and connect the left Z0 transmission line
    tline_left = c.add_ref(
        tline(
            length=quater_wave_length - width_Z0_sqrt2,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    tline_left.connect("e1", corner_nw.ports["e1"])

    # create and connect the bottom left corner
    corner_sw = c.add_ref(corner).mirror(p1=(0, 0), p2=(1, 0))

    corner_sw.connect("e1", tline_left.ports["e2"])

    # create and connect the bottom Z0/sqrt(2) transmission line
    tline_bottom = c.add_ref(
        tline(
            length=quater_wave_length - width_Z0,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0_sqrt2,
        )
    )

    tline_bottom.connect("e1", corner_sw.ports["e2"])

    # create and connect the bottom right corner
    corner_se = (
        c.add_ref(corner).mirror(p1=(0, 0), p2=(1, 0)).mirror(p1=(0, 0), p2=(0, 1))
    )

    corner_se.connect("e2", tline_bottom.ports["e2"])

    # create and connect the right Z0 transmission line
    tline_right = c.add_ref(
        tline(
            length=quater_wave_length - width_Z0_sqrt2,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    tline_right.connect("e1", corner_ne.ports["e1"])

    # create and connect input/output lines
    connection1 = c.add_ref(
        tline(
            length=connection_length,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    connection1.connect("e1", corner_nw.ports["e3"])

    connection2 = c.add_ref(
        tline(
            length=connection_length,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    connection2.connect("e1", corner_ne.ports["e3"])

    connection3 = c.add_ref(
        tline(
            length=connection_length,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    connection3.connect("e1", corner_se.ports["e3"])

    connection4 = c.add_ref(
        tline(
            length=connection_length,
            signal_cross_section=signal_cross_section,
            ground_cross_section=ground_cross_section,
            width=width_Z0,
        )
    )

    connection4.connect("e1", corner_sw.ports["e3"])

    # add ports to the component
    c.add_port(name="e1", port=connection1.ports["e2"])
    c.add_port(name="e2", port=connection2.ports["e2"])
    c.add_port(name="e3", port=connection3.ports["e2"])
    c.add_port(name="e4", port=connection4.ports["e2"])

    return c

@gf.cell(schematic_function=cmim_schematic, tags=["IHP", "capacitor", "mim"])
def cmim(
    width: float = 6.0,
    length: float = 6.0,
    layer_metal5: LayerSpec = "Metal5drawing",
    layer_mim: LayerSpec = "MIMdrawing",
    layer_vmim: LayerSpec = "Vmimdrawing",
    layer_topmetal1: LayerSpec = "TopMetal1drawing",
    layer_cap_mark: LayerSpec = "MemCapdrawing",
    layer_m4nofill: LayerSpec = "Metal4nofill",
    layer_m5nofill: LayerSpec = "Metal5nofill",
    layer_tm1nofill: LayerSpec = "TopMetal1nofill",
    layer_tm2nofill: LayerSpec = "TopMetal2nofill",
    layer_text: LayerSpec = "TEXTdrawing",
    layer_metal5label: LayerSpec = "Metal5label",
    layer_topmetal1label: LayerSpec = "TopMetal1label",
    layer_metal5pin: LayerSpec = "Metal5pin",
    layer_topmetal1pin: LayerSpec = "TopMetal1pin",
    model: str = "cmim",
    **kwargs,
) -> Component:
    """Create a MIM (Metal-Insulator-Metal) capacitor.

    Args:
        width: Width of the capacitor in micrometers.
        length: Length of the capacitor in micrometers.
        bot_enclosure: Bottol Metal5 layer enclosure
        top_enclosure:
        layer_metal5: Metal 5 drawing layer.
        layer_mim: MIM device drawing layer.
        layer_vmim: Vmim (MIM-TopMetal1 Via) drawing layer.
        layer_topmetal1: TopMetal1 drawing layer.
        layer_cap_mark: MemCap drawing layer.
        layer_m4nofill: Metal4 nofill logic layer.
        layer_m5nofill: Metal5 nofill logic layer.
        layer_tm1nofill: TopMetal1 nofill logic layer.
        layer_tm2nofill: TopMetal2 nofill logic layer.
        layer_text: TEXT drawing layer.
        layer_metal5label: Metal5 label logic layer.
        layer_topmetal1label: TopMetal1 label logic layer.
        layer_metal5pin: Metal5 pin logic layer.
        layer_topmetal1pin: TopMetal1 pin logic layer.

        model: Device model name.

    Returns:
        Component with MIM capacitor layout.

    Raises:
        ValueError: If width or length is outside allowed range.
    """
    if width < tech.TECH.cmim_min_size or width > tech.TECH.cmim_max_size:
        raise ValueError(
            f"cmim width={width} out of range [{tech.TECH.cmim_min_size}, {tech.TECH.cmim_max_size}]"
        )
    if length < tech.TECH.cmim_min_size or length > tech.TECH.cmim_max_size:
        raise ValueError(
            f"cmim length={length} out of range [{tech.TECH.cmim_min_size}, {tech.TECH.cmim_max_size}]"
        )

    c = Component()

    mim_drc = {
        # capacitor
        "mim_min_size": tech.TECH.mim_min_size,
        "mim_cap_density": tech.TECH.mim_cap_density,
        # metals
        "m5_min_width": tech.TECH.metal5_width,
        "m5_min_spacing": tech.TECH.metal5_spacing,
        "topmetal1_width": tech.TECH.topmetal1_width,
        "topmetal1_spacing": tech.TECH.topmetal1_spacing,
        # vias
        "vmim_size": 0.42,
        "vmim_spacing": 0.52,
        "vmim_enc_metal": 0.42,
        "vmim_enc": 0.6,  # bot_enclosure
        "mim_enc": 0.36,  # top_enclosure
    }

    bot_enclosure = mim_drc["vmim_enc"]
    top_enclosure = mim_drc["mim_enc"]

    # snap to grid
    grid = tech.TECH.grid
    width = round(width / grid) * grid
    length = round(length / grid) * grid

    # build capacitor stack

    # Bottom plate (Metal4)
    bottom_plate_width = width + 2 * bot_enclosure + 2 * top_enclosure
    bottom_plate_length = length + 2 * bot_enclosure + 2 * top_enclosure

    bottom_plate = gf.components.rectangle(
        size=(bottom_plate_length, bottom_plate_width),
        layer=layer_metal5,
        centered=True,
    )
    bot = c.add_ref(bottom_plate)

    # MIM layer
    mim_layer = gf.components.rectangle(
        size=(length + 2 * top_enclosure, width + 2 * top_enclosure),
        layer=layer_mim,
        centered=True,
    )
    c.add_ref(mim_layer)

    # add vmim via array
    vmim_min_width = mim_drc["vmim_size"] + mim_drc["vmim_spacing"]
    nrows = int(floor(width / vmim_min_width))
    ncols = int(floor(length / vmim_min_width))

    # Top plate (TopMetal1)
    top_plate = gf.components.rectangle(
        size=(length, width),
        layer=layer_topmetal1,
        centered=True,
    )
    top = c.add_ref(top_plate)

    vmim_array = via_array(
        via_type=layer_vmim.split("drawing")[0],
        via_size=mim_drc["vmim_size"],
        via_spacing=mim_drc["vmim_size"] + mim_drc["vmim_spacing"],
        via_enclosure=mim_drc["vmim_enc_metal"],
        columns=ncols,
        rows=nrows,
    )
    vias = c.add_ref(vmim_array)
    vias.x = top.x
    vias.y = top.y

    # Add no fill logic layers

    logic = [
        layer_cap_mark,
        layer_m4nofill,
        layer_m5nofill,
        layer_tm1nofill,
        layer_tm2nofill,
    ]
    for layer_spec in logic:
        ll = gf.components.rectangle(
            size=(bottom_plate_length, bottom_plate_width),
            layer=layer_spec,
            centered=True,
        )
        c.add_ref(ll)

    minus = c.add_port(
        name="MINUS",
        center=(bot.xmin + mim_drc["m5_min_width"] / 2, bot.y),
        width=mim_drc["m5_min_width"],
        orientation=180,
        layer=layer_metal5pin,
        port_type="electrical",
    )

    plus = c.add_port(
        name="PLUS",
        center=(top.xmax - mim_drc["topmetal1_width"] / 2, top.y),
        width=mim_drc["topmetal1_width"],
        orientation=0,
        layer=layer_topmetal1pin,
        port_type="electrical",
    )

    pin_minus = gf.components.rectangle(
        size=(mim_drc["topmetal1_width"], 2 * mim_drc["topmetal1_width"]),
        layer=layer_metal5pin,
        centered=True,
    )
    pin_minus_ref = c.add_ref(pin_minus)
    pin_minus_ref.xmin = bot.xmin
    pin_minus_ref.y = minus.y

    pin_plus = gf.components.rectangle(
        size=(mim_drc["topmetal1_width"], 2 * mim_drc["topmetal1_width"]),
        layer=layer_topmetal1pin,
        centered=True,
    )
    pin_plus_ref = c.add_ref(pin_plus)
    pin_plus_ref.xmax = top.xmax
    pin_plus_ref.y = plus.y

    c.add_label(
        text="PLUS",
        position=(top.xmax - mim_drc["topmetal1_width"] / 2, top.y),
        layer=layer_text,
    )
    c.add_label(
        text="MINUS",
        position=(bot.xmin + mim_drc["m5_min_width"] / 2, bot.y),
        layer=layer_text,
    )

    c.add_label(text=model, position=(c.x, c.y + width / 2), layer=layer_text)

    # fringe_factor = kwargs.get("fringe_factor", 0.355)
    # capacitance = width * length * mim_drc['mim_cap_density']
    # capacitance *= (1+fringe_factor)
    capacitance = CbCapCalc("C", 0, length, width, model)

    c.add_label(
        text=f"C = {capacitance} fF", position=(c.x, c.y - width / 2), layer=layer_text
    )

    c.info["model"] = model
    c.info["width"] = width
    c.info["length"] = length
    c.info["capacitance_fF"] = capacitance
    c.info["area_um2"] = width * length

    return c