PCells

@gf.cell_with_module_name(schematic_function=inductor_schematic, tags=["analog"])
def inductor(
    width: float = 2.0,
    space: float = 2.1,
    diameter: float = 25.35,
    resistance: float = 0.5777,
    inductance: float = 33.303e-12,
    turns: int = 1,
    layer_metal: LayerSpec = "M3",
    layer_inductor: LayerSpec = "M1",
    layer_metal_pin: LayerSpec = "WG_PIN",
    layers_no_fill: LayerSpecs = ("DEVREC", "NO_TILE_SI"),
) -> Component:
    """Create a 2-turn inductor.

    Args:
        width: Width of the inductor trace in micrometers.
        space: Space between turns in micrometers.
        diameter: Inner diameter in micrometers.
        resistance: Resistance in ohms.
        inductance: Inductance in henries.
        turns: Number of turns (default 1 for inductor2).
        layer_metal: Layer for the metal trace.
        layer_inductor: Layer for the inductor region.
        layer_metal_pin: Layer for the metal pins.
        layers_no_fill: Layers to exclude from fill.

    Returns:
        Component with inductor layout.
    """
    return cf.inductor(
        width=width,
        space=space,
        diameter=diameter,
        resistance=resistance,
        inductance=inductance,
        turns=turns,
        layer_metal=layer_metal,
        layer_inductor=layer_inductor,
        layer_metal_pin=layer_metal_pin,
        layers_no_fill=layers_no_fill,
    )

@gf.cell_with_module_name(tags=["analog"])
def spiral_inductor(
    d_out: float = 130.0,
    N: int = 3,
    sides: int = 8,
    width: float = 10.0,
    spacing: float = 4.0,
    aspect_ratio: float = 1.0,
    port_side: str = "same",
    add_pgs: bool = False,
    pgs_diameter: float = 150.0,
    pgs_width: float = 2.0,
    pgs_spacing: float = 1.0,
    via: ComponentSpec = "via2",
    resistance: float = 0.5777,
    inductance: float = 33.303e-12,
    layer_winding: LayerSpec = "M3",
    layer_underpass: LayerSpec = "M2",
    layers_pgs: LayerSpecs = ("M1",),
) -> Component:
    """Polygonal spiral inductor.

    Args:
        d_out: Outer diameter of the spiral in micrometers.
        N: Number of complete turns.
        sides: Number of polygon sides per full turn (8 = octagonal).
        width: Metal trace width in micrometers.
        spacing: Gap between adjacent turns in micrometers.
        aspect_ratio: Y-axis scale factor for non-square spirals (1.0 = symmetric).
        port_side: ``"same"`` keeps both ports on the same side;
            ``"opposite"`` places them on opposite sides.
        add_pgs: When True, add a patterned ground shield on layers_pgs.
        pgs_diameter: Bounding size D of the ground shield square, in micrometers.
        pgs_width: Strip width w of each ground shield finger, in micrometers.
        pgs_spacing: Gap s between adjacent ground shield fingers, in micrometers.
        via: via ComponentSpec connecting winding <-> underpass.
        resistance: Series resistance in ohms, stored as metadata only.
        inductance: Inductance in henries, stored as metadata only.
        layer_winding: Metal layer for the main spiral winding.
        layer_underpass: Metal layer for the inner-terminal underpass bridge (one layer below layer_winding).
        layers_pgs: Layers on which the patterned ground shield is drawn,
            kept separate from both layer_winding and layer_underpass
            since the underpass carries a live signal and shouldn't s
            hare a layer with a grounded shield.

    Returns:
        Component with 2 RF ports:
          P1  ->  entry terminal  (layer_winding)
          P2  ->  exit terminal   (layer_underpass)
    """
    return cf.analog.inductors.spiral_inductor(
        d_out=d_out,
        N=N,
        sides=sides,
        width=width,
        spacing=spacing,
        aspect_ratio=aspect_ratio,
        port_side=port_side,
        add_pgs=add_pgs,
        pgs_diameter=pgs_diameter,
        pgs_width=pgs_width,
        pgs_spacing=pgs_spacing,
        via=via,
        resistance=resistance,
        inductance=inductance,
        layer_winding=layer_winding,
        layer_underpass=layer_underpass,
        layers_pgs=layers_pgs,
    )

@gf.cell_with_module_name(tags=["analog"])
def stacked_transformer(
    d_out: float = 150.0,
    N1: int = 3,
    N2: int = 3,
    sides: int = 8,
    width: float = 10.0,
    spacing: float = 2.0,
    center_tap_primary: bool = False,
    center_tap_secondary: bool = False,
    via_extent: float | None = None,
    port_spacing: float | None = None,
    via_primary: ComponentSpec = "via3",
    via_secondary: ComponentSpec = "via1",
    resistance: float = 0.5777,
    inductance: float = 33.303e-12,
    add_pgs: bool = False,
    pgs_diameter: float = 180.0,
    pgs_width: float = 4.0,
    pgs_spacing: float = 2.0,
    # Defaults use the synthetic M4/VIA3 layers for full 4-metal isolation —
    # see the module-level comment above M4_LAYER for the SIMULATION
    # PIPELINE WARNING: use get_extended_layer_stack() with sim.set_stack(),
    # not the PDK default, when meshing a component built with these.
    layer_winding_primary: LayerSpec | None = None,
    layer_crossing_primary: LayerSpec = "M3",
    layer_winding_secondary: LayerSpec = "M2",
    layer_crossing_secondary: LayerSpec = "M1",
    layers_pgs: LayerSpecs = (),
) -> Component:
    """Stacked transformer.

    The primary winding sits on layer_winding_primary with
    its crossings on layer_crossing_primary (connected by via_primary);
    the secondary winding sits on layer_winding_secondary with its
    crossings on layer_crossing_secondary (connected by via_secondary),
    mirrored to sit on the opposite side of d_out so the two windings
    stack vertically over the same footprint.

    LAYER STACK: this gdsfactory generic PDK only has 3 real metals
    (M1/M2/M3). A fully isolated stacked transformer needs 4 independent
    metals (primary winding, primary crossing, secondary winding,
    secondary crossing), so the defaults here use an EXTRA, non-native
    4th metal registered via gf.kcl.layer() at import time (M4_LAYER,
    layer (53, 0)) with its own via (via3(), VIA3_LAYER, layer (48, 0))
    connecting it to M3. This gives full primary/secondary isolation by
    default:
        layer_winding_primary=M4_LAYER, layer_crossing_primary="M3", via_primary=via3
        layer_winding_secondary="M2",   layer_crossing_secondary="M1", via_secondary="via1"

    M4_LAYER/VIA3_LAYER are valid GDS layers but are NOT part of this PDK's real,
    fabricatable metal stack. If you need this component to be simulation-ready
    (Palace/gsim meshing) ortape-out-accurate, call get_extended_layer_stack()
    instead of the PDK's default stack, e.g. sim.set_stack(stack=get_extended_layer_stack()).

    If your ACTUAL target PDK has a genuine 4th metal, pass its real
    layer name/via in place of M4_LAYER/via3 instead of relying on this
    synthetic one.

    layers_pgs defaults to an empty tuple: even with M4 in play, all of
    M1/M2/M3/M4 are live signal layers in the default configuration, so
    there's still no obviously-safe spare metal for a patterned ground
    shield — pass an explicit LayerSpecs of your own (accepting whatever
    coupling that implies) if you need one anyway.

    Args:
        d_out: Outer diameter of each winding, in micrometers.
        N1: Number of turns in the primary winding.
        N2: Number of turns in the secondary winding.
        sides: Number of polygon sides per full turn (8 = octagonal).
        width: Metal trace width in micrometers.
        spacing: Gap between adjacent turns in micrometers.
        center_tap_primary: When True, add a center-tap bridge and CT_P
            port to the primary winding.
        center_tap_secondary: When True, add a center-tap bridge and CT_S
            port to the secondary winding.
        via_extent: Length crossing routes extend past their crossing box,
            and the box size used to size the crossing/centertap via
            arrays, for both halves. If None, it's derived independently
            for each half from that half's own via geometry (same
            derivation spiral_inductor/symmetric_inductor use).
        port_spacing: Horizontal spacing of both differential port pairs.
            Defaults to spacing.
        via_primary: via ComponentSpec connecting layer_winding_primary <-> layer_crossing_primary.
        via_secondary: via ComponentSpec connecting layer_winding_secondary <-> layer_crossing_secondary.
        resistance: Series resistance in ohms, stored as metadata only.
        inductance: Inductance in henries, stored as metadata only.
        add_pgs: When True, add a patterned ground shield on layers_pgs.
            See the layer-stack caveat above before enabling this.
        pgs_diameter: Bounding size D of the ground shield square, in micrometers.
        pgs_width: Strip width w of each ground shield finger, in micrometers.
        pgs_spacing: Gap s between adjacent ground shield fingers, in micrometers.
        layer_winding_primary: Metal layer for the primary winding.
        layer_crossing_primary: Metal layer for the primary crossings.
        layer_winding_secondary: Metal layer for the secondary winding.
        layer_crossing_secondary: Metal layer for the secondary crossings.
        layers_pgs: Layers on which the patterned ground shield is drawn.

    Returns:
        Component with 4-6 ports:
          P+ / P-    ->  primary differential terminals   (layer_winding_primary)
          S+ / S-    ->  secondary differential terminals (layer_winding_secondary)
          CT_P       ->  present if center_tap_primary=True
          CT_S       ->  present if center_tap_secondary=True
    """
    return cf.stacked_transformer(
        d_out=d_out,
        N1=N1,
        N2=N2,
        sides=sides,
        width=width,
        spacing=spacing,
        center_tap_primary=center_tap_primary,
        center_tap_secondary=center_tap_secondary,
        via_extent=via_extent,
        port_spacing=port_spacing,
        via_primary=via_primary,
        via_secondary=via_secondary,
        resistance=resistance,
        inductance=inductance,
        add_pgs=add_pgs,
        pgs_diameter=pgs_diameter,
        pgs_width=pgs_width,
        pgs_spacing=pgs_spacing,
        layer_winding_primary=layer_winding_primary,
        layer_crossing_primary=layer_crossing_primary,
        layer_winding_secondary=layer_winding_secondary,
        layer_crossing_secondary=layer_crossing_secondary,
        layers_pgs=layers_pgs,
    )

@gf.cell_with_module_name(tags=["analog"])
def symmetric_inductor(
    d_out: float = 150.0,
    N: int = 3,
    sides: int = 8,
    width: float = 10.0,
    spacing: float = 2.0,
    center_tap: bool = False,
    via_extent: float | None = None,
    port_spacing: float | None = None,
    aspect_ratio: float = 1.0,
    via: ComponentSpec = "via2",
    resistance: float = 0.5777,
    inductance: float = 33.303e-12,
    add_pgs: bool = False,
    pgs_diameter: float = 180.0,
    pgs_width: float = 4.0,
    pgs_spacing: float = 2.0,
    layer_winding: LayerSpec = "M3",
    layer_underpass: LayerSpec = "M2",
    layers_pgs: LayerSpecs = ("M1",),
) -> Component:
    """Symmetric (differential) spiral inductor.

    Args:
        d_out: Outer diameter of the two-lobe structure, in micrometers.
        N: Number of complete windings per side.
        sides: Number of polygon sides per full turn (8 = octagonal).
        width: Metal trace width in micrometers.
        spacing: Gap between adjacent turns in micrometers.
        center_tap: When True, add a center-tap bridge (and CT port)
            routed through layer_underpass with its own via connection
            to the winding.
        via_extent: Length the crossing route extends past the crossing
            box on layer_underpass, and the box size used to size the
            crossing/centertap via arrays. If None, it's derived from the
            chosen via's own geometry.
        port_spacing: Horizontal spacing of the differential ports P1/P2.
        aspect_ratio: Y-axis scale factor for non-square windings
        via: via ComponentSpec connecting winding <-> crossing/centertap.
        resistance: Series resistance in ohms, stored as metadata only
        inductance: Inductance in henries, stored as metadata only
        add_pgs: When True, add a patterned ground shield on layers_pgs.
        pgs_diameter: Bounding size D of the ground shield square, in micrometers.
        pgs_width: Strip width w of each ground shield finger, in micrometers.
        pgs_spacing: Gap s between adjacent ground shield fingers, in micrometers.
        layer_winding: Metal layer for the main winding (top metal).
        layer_underpass: Metal layer for crossings and the center-tap bridge (one layer below layer_winding).
        layers_pgs: Layers on which the patterned ground shield is drawn.

    Returns:
        Component with 2 or 3 ports:
          P1  ->  left differential terminal   (layer_winding)
          P2  ->  right differential terminal  (layer_winding)
          CT  ->  center tap (only if center_tap=True), on layer_winding
                  if N <= 2, else on layer_underpass.
    """
    return cf.analog.inductors.symmetric_inductor(
        d_out=d_out,
        N=N,
        sides=sides,
        width=width,
        spacing=spacing,
        center_tap=center_tap,
        via_extent=via_extent,
        port_spacing=port_spacing,
        aspect_ratio=aspect_ratio,
        via=via,
        resistance=resistance,
        inductance=inductance,
        add_pgs=add_pgs,
        pgs_diameter=pgs_diameter,
        pgs_width=pgs_width,
        pgs_spacing=pgs_spacing,
        layer_winding=layer_winding,
        layer_underpass=layer_underpass,
        layers_pgs=layers_pgs,
    )

@gf.cell_with_module_name(tags=["analog"])
def symmetric_transformer(
    d_out: float = 150.0,
    N1: int = 2,
    N2: int = 3,
    sides: int = 8,
    width: float = 7.0,
    spacing: float = 2.0,
    center_tap_primary: bool = False,
    center_tap_secondary: bool = False,
    via_extent: float | None = None,
    port_spacing: float | None = None,
    via: ComponentSpec = "via2",
    resistance: float = 0.5777,
    inductance: float = 33.303e-12,
    add_pgs: bool = False,
    pgs_diameter: float = 180.0,
    pgs_width: float = 4.0,
    pgs_spacing: float = 2.0,
    layer_winding: LayerSpec = "M3",
    layer_underpass: LayerSpec = "M2",
    layers_pgs: LayerSpecs = ("M1",),
) -> Component:
    """Symmetric (interleaved) transformer.

    Two interleaved windings (primary: N1 turns, secondary: N2 turns) share
    the same octagonal spiral, alternating turn-by-turn. Crossings are
    routed on layer_underpass wherever a turn boundary needs to jump
    between quadrants; bridges wire together the top/bottom/left/right
    quadrant segments directly on layer_winding.

    Args:
        d_out: Outer diameter of the winding structure, in micrometers.
        N1: Number of turns in the primary winding.
        N2: Number of turns in the secondary winding.
        sides: Number of polygon sides per full turn (8 = octagonal).
            Must be a multiple of 4 (quadrant angle lists use sides // 4).
        width: Metal trace width in micrometers.
        spacing: Gap between adjacent turns in micrometers.
        center_tap_primary: When True, add a center-tap bridge (and CT1 or
            CT2 port, depending on parity) for the primary winding.
        center_tap_secondary: When True, add a center-tap bridge (and CT1
            or CT2 port, depending on parity) for the secondary winding.
        via_extent: Length crossing/bridge routes extend past their
            crossing box on layer_underpass, and the box size used to size
            the crossing/centertap via arrays. If None, it's derived from
            the chosen via's own geometry the same way spiral_inductor and
            symmetric_inductor derive their "extend" value.
        port_spacing: Horizontal spacing of the differential port pairs.
        via: via ComponentSpec connecting winding <-> crossing/centertap.
        resistance: Series resistance in ohms, stored as metadata only.
        inductance: Inductance in henries, stored as metadata only.
        add_pgs: When True, add a patterned ground shield on layers_pgs.
        pgs_diameter: Bounding size D of the ground shield square, in micrometers.
        pgs_width: Strip width w of each ground shield finger, in micrometers.
        pgs_spacing: Gap s between adjacent ground shield fingers, in micrometers.
        layer_winding: Metal layer for the main winding (top metal).
        layer_underpass: Metal layer for crossings and center-tap bridges (one layer below layer_winding).
        layers_pgs: Layers on which the patterned ground shield is drawn,
            kept separate from both layer_winding and layer_underpass

    Returns:
        Component with 4-6 ports:
          P1+ / P1-  ->  primary differential terminals   (bottom, layer_winding)
          P2+ / P2-  ->  secondary differential terminals (top, layer_winding)
          CT1        ->  present if a center tap lands on the bottom side
          CT2        ->  present if a center tap lands on the top side
    """
    return cf.symmetric_transformer(
        d_out=d_out,
        N1=N1,
        N2=N2,
        sides=sides,
        width=width,
        spacing=spacing,
        center_tap_primary=center_tap_primary,
        center_tap_secondary=center_tap_secondary,
        via_extent=via_extent,
        port_spacing=port_spacing,
        via=via,
        resistance=resistance,
        inductance=inductance,
        add_pgs=add_pgs,
        pgs_diameter=pgs_diameter,
        pgs_width=pgs_width,
        pgs_spacing=pgs_spacing,
        layer_winding=layer_winding,
        layer_underpass=layer_underpass,
        layers_pgs=layers_pgs,
    )

@gf.cell
def transformer_concentric_secondary(
    width: float = 3.0,
    space: float = 3.1,
    diameter: float = 50.0,
    layer_metal: LayerSpec = "M2",
    layer_jumper: LayerSpec = "M1",
    via: ComponentSpec = "via1",
    via_size: float = 3.0,
) -> Component:
    """Single-turn octagonal coil, the secondary of transformer_concentric.

    The two leads jump to a lower metal (layer_jumper) right where
    they meet the coil body, so the leads can be routed straight out
    past an outer coil without shorting it.

    Args:
        width: Metal trace width in micrometers.
        space: Space between the coil and the leads/gap, in micrometers.
        diameter: Coil diameter in micrometers.
        layer_metal: Layer for the coil body.
        layer_jumper: Layer for the two leads (must be via-connectable
            to layer_metal).
        via: via ComponentSpec connecting layer_jumper <-> layer_metal.
        via_size: Side length of the square via_stack junction pad, in
            micrometers. via_stack() requires this to be large enough to
            enclose at least one via square with its enclosure margin —
            too small raises a ValueError from via_stack() itself.

    Returns:
        Component with ports P1, P2 on layer_jumper.
    """
    return cf.transformer_concentric_secondary(
        width=width,
        space=space,
        diameter=diameter,
        layer_metal=layer_metal,
        layer_jumper=layer_jumper,
        via=via,
        via_size=via_size,
    )

@gf.cell
def via3(
    size: tuple[float, float] = (0.7, 0.7),
    enclosure: float = 1.0,
    pitch: float = 2.0,
) -> Component:
    """Via connecting M3 <-> M4, mirroring via1/via2/viac's shape (0.7x0.7um squares, 1um enclosure, 2um pitch) but on VIA3_LAYER.

    Only meaningful once M4 also has real z-geometry — see
    get_extended_layer_stack() for the matching LayerStack entry.

    Args:
        size: (width, height) of the via square, in um.
        enclosure: metal enclosure around the via, in um.
        pitch: via array pitch, in um.
    """
    return cf.via3(
        size=size,
        enclosure=enclosure,
        pitch=pitch,
    )

@gf.vcell
def bend_circular_all_angle(
    radius: float | None = None,
    angle: float = 90.0,
    npoints: int | None = None,
    angular_step: float | None = None,
    layer: gf.typings.LayerSpec | None = None,
    width: float | None = None,
    cross_section: CrossSectionSpec = "strip",
    allow_min_radius_violation: bool = False,
) -> ComponentAllAngle:
    """Returns a radial arc.

    Args:
        radius: in um. Defaults to cross_section_radius.
        angle: angle of arc (degrees).
        npoints: number of points.
        angular_step: If provided, determines the angular step (in degrees) between points. Mutually exclusive with npoints.
        layer: layer to use. Defaults to cross_section.layer.
        width: width to use. Defaults to cross_section.width.
        cross_section: spec (CrossSection, string or dict).
        allow_min_radius_violation: if True allows radius to be smaller than cross_section radius.
    """
    return cf.bend_circular_all_angle(
        radius=radius,
        angle=angle,
        npoints=npoints,
        angular_step=angular_step,
        layer=layer,
        width=width,
        cross_section=cross_section,
        allow_min_radius_violation=allow_min_radius_violation,
    )

@gf.vcell
def bend_euler_all_angle(
    radius: float | None = None,
    angle: float = 90.0,
    p: float = 0.5,
    with_arc_floorplan: bool = True,
    npoints: int | None = None,
    angular_step: float | None = None,
    layer: gf.typings.LayerSpec | None = None,
    width: float | None = None,
    cross_section: CrossSectionSpec = "strip",
    allow_min_radius_violation: bool = False,
) -> ComponentAllAngle:
    """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.
        with_arc_floorplan: If False: `radius` is the minimum radius of curvature
        npoints: Number of points used per 360 degrees.
        angular_step: if not None, the angle step in degrees for the all_angle bend.
        layer: layer to use. Defaults to cross_section.layer.
        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 cf.bend_euler_all_angle(
        radius=radius,
        angle=angle,
        p=p,
        with_arc_floorplan=with_arc_floorplan,
        npoints=npoints,
        angular_step=angular_step,
        layer=layer,
        width=width,
        cross_section=cross_section,
        allow_min_radius_violation=allow_min_radius_violation,
    )