better via_stack_with_offset

gdsfactory/components/ring_section_based.py

@@ -13,12 +13,13 @@
 from gdsfactory.typings import CrossSectionSpec, Union, List, Tuple, Floats
 from gdsfactory.components.bend_circular import bend_circular
 from gdsfactory.components.straight import straight
+from gdsfactory.cell import cell_without_validator
 
 def_dict = {"A": "rib", "B": "strip"}
 def_ang_dict = {"A": 6, "B": 6}
 
 
-@gf.cell
+@cell_without_validator
 def ring_section_based(
     gap: Union[float, Floats] = 0.3,
     radius: float = 5.0,
@@ -67,7 +68,7 @@
     angular_extent_sequence = 360
 
     if not isinstance(gap, Union[List, Tuple]):
         gap = [gap] * 2
 
     # See if we need to add initial cross sections
     if start_cross_section is not None:
@@ -78,22 +79,22 @@
             angular_extent_sequence -= start_angle
 
             if not isinstance(cross_sections_sequence, Union[List, Tuple]):
                 cross_sections_sequence = [cross_sections_sequence] * 2
 
     if cross_sections_angles is None:
         if add_drop:
             n_sections_0 = len(cross_sections_sequence[0])
             sing_sec_ang_1 = angular_extent_sequence / (2 * n_sections_0)
             n_sections_1 = len(cross_sections_sequence[1])
             sing_sec_ang_2 = angular_extent_sequence / (2 * n_sections_1)
             cross_sections_angles = {
                 elem: sing_sec_ang_1 for elem in cross_sections_sequence[0]
             }
             for elem in cross_sections_sequence[1]:
                 cross_sections_angles[elem] = sing_sec_ang_2
 
         else:
             n_sections = len(cross_sections_sequence)
             sing_sec_ang = angular_extent_sequence / n_sections
             cross_sections_angles = {
                 elem: sing_sec_ang for elem in cross_sections_sequence
@@ -106,12 +107,12 @@
             [cross_sections_angles[sec] for sec in cross_sections_sequence]
         )
         if not (angular_extent_sequence / sing_seq_angular_extent).is_integer():
             raise ValueError(
                 "The specified sequence angles do not result in an integer number "
                 "of sequences fitting in the ring."
             )
         else:
             n_repeats_seq = int(angular_extent_sequence / sing_seq_angular_extent)
 
     else:
         sing_seq_angular_extent_0 = np.sum(
@@ -122,7 +123,7 @@
         )
 
         if (angular_extent_sequence / (sing_seq_angular_extent_0 * 2)).is_integer():
             n_repeats_seq_0 = int(
                 angular_extent_sequence / (sing_seq_angular_extent_0 * 2)
             )
         else:
@@ -132,26 +133,22 @@
             )
 
         if (angular_extent_sequence / (sing_seq_angular_extent_1 * 2)).is_integer():
             n_repeats_seq_1 = int(
                 angular_extent_sequence / (sing_seq_angular_extent_1 * 2)
             )
         else:
             raise ValueError(
                 "The specified sequence 2 angles do not result in an integer "
                 "number of sequences fitting in the ring."
             )
 
-        print(n_repeats_seq_0)
-
     # Now we are ready to construct the ring
 
     # We need to create a circular bend for each section
     sections_dict = {}
 
-    for key in cross_sections.keys():
+    for key, xsec in cross_sections.items():
         ang = cross_sections_angles[key]
-        xsec = cross_sections[key]
-
         b = bend_circular(angle=ang, with_bbox=False, cross_section=xsec, radius=radius)
 
         sections_dict[key] = (b, "o1", "o2")
@@ -167,17 +164,17 @@
         sections_dict["0"] = (b, "o1", "o2")
 
     if drop_cross_section is not None:
         b = bend_circular(
             angle=start_angle,
             with_bbox=False,
             cross_section=gf.get_cross_section(drop_cross_section),
             radius=radius,
         )
         if "1" in sections_dict:
             raise ValueError(
                 "Please do not have '1' as a key for the cross_sections dict"
             )
         sections_dict["1"] = (b, "o1", "o2")
 
     # Now we just need to generate a chain of characters
     # to creae the sequence
@@ -188,18 +185,18 @@
         sequence += "0"
 
     if not add_drop:
         sequence += cross_sections_sequence * n_repeats_seq
 
     else:
         sequence += cross_sections_sequence[0] * n_repeats_seq_0
 
         if drop_cross_section is None and start_cross_section is not None:
             sequence += "0"
         elif drop_cross_section is not None:
             sequence += "1"
 
         seq_2 = cross_sections_sequence[1] * n_repeats_seq_1
         sequence += seq_2
 
     ring = gf.components.component_sequence(
         sequence=sequence, symbol_to_component=sections_dict
@@ -234,19 +231,19 @@
         if start_cross_section
         else gf.get_cross_section(cross_sections[cross_sections_sequence[0]]).layer
     )
     ring_guide_add = ring.extract([input_xs_layer])
 
     if drop_cross_section:
         drop_xs_layer = gf.get_cross_section(drop_cross_section).layer
     elif start_cross_section:
         drop_xs_layer = input_xs_layer
     else:
         drop_xs_layer = gf.get_cross_section(
             cross_sections[cross_sections_sequence[0]]
         ).layer
 
     ring_guide_add = ring.extract([input_xs_layer])
     ring_guide_drop = ring.extract([drop_xs_layer])
 
     # Add bus waveguides
     s = straight(length=ring.xsize, cross_section=bus_cross_section)
@@ -256,13 +253,13 @@
 
     s_add = c << s
     s_add.x = r.x
     s_add.ymax = ring_guide_add.ymin - gap[0] + s.ysize / 2 - input_xs_width / 2
 
     if add_drop:
         s.mirror((0, 1))
         s_drop = c << s
         s_drop.x = r.x
         s_drop.ymin = ring_guide_drop.ymax + gap[1] - s.ysize / 2 + input_xs_width / 2
 
     # Add ports
     c.add_port("o1", port=s_add.ports["o1"])
@@ -306,4 +303,4 @@
     # c = ring_section_based(add_drop=True)
 
     c.show(show_ports=True)
-    print(c.info["ring_center"])
+    # print(c.info["ring_center"])

gdsfactory/components/via_stack.py

@@ -87,9 +87,9 @@
                 and min_height > height
                 and correct_size
             ):
                 print("Changing sizes to fit a via! Check this is desired")
                 width = max(min_width, width)
                 height = max(min_height, height)
             elif min_width > width or min_height > height:
                 raise ValueError(f"size {size} is too small to fit a {(w, h)} um via")
 
@@ -114,7 +114,7 @@
 
 
 @gf.cell
-def circular_via_stack(
+def via_stack_circular(
     radius: float = 10.0,
     angular_extent: float = 45,
     center_angle: float = 0,
@@ -125,6 +125,8 @@
 ) -> Component:
     """Circular via array stack.
 
+    FIXME! does not work.
+
     Constructs a circular via array stack. It does so
     by stacking rectangular via stacks offset by a small amount
     along the specified circumference.
@@ -141,26 +143,24 @@
 
     # We basically just want to place rectangular via stacks
     # stacked with a little bit of an offset
     c = gf.Component()
 
     layers = layers or []
 
     if layers:
         layer_port = layer_port or layers[-1]
 
     init_angle = (center_angle - angular_extent / 2) * np.pi / 180
     end_angle = (center_angle + angular_extent / 2) * np.pi / 180
 
     init_angle = init_angle % (2 * np.pi)
     if init_angle > np.pi:
         init_angle = init_angle - 2 * np.pi
 
     end_angle = end_angle % (2 * np.pi)
     if end_angle > np.pi:
         end_angle = end_angle - 2 * np.pi
 
-    print(end_angle * 180 / np.pi)
-
     # We do this via-centric: we figure out the min spacing between vias,
     # and from that figure out all the metal dimensions
     # This will of course fail if no via information is provided,
@@ -168,78 +168,68 @@
 
     for level, via_type in enumerate(vias):
         if via_type is None:
             continue
 
         metal_bottom = layers[level]
         metal_top = layers[level + 1]
-
         via_type = gf.get_component(via_type)
 
-        # Get via info
         w, h = via_type.info["size"]
         g = via_type.info["enclosure"]
         pitch_x, pitch_y = via_type.info["spacing"]
 
         nb_vias_x = (width - w - 2 * g) / pitch_x + 1
         nb_vias_x = int(np.floor(nb_vias_x)) or 1
 
         size_metal = (width, h + 2 * g)
 
         # Now start placing via lines at each angle starting from
         # the initial angle until we reach the end angle
         ang = init_angle
 
         while _smaller_angle(ang, ang, end_angle):
             pos = radius * np.array((np.cos(ang), np.sin(ang)))
 
             ref = c.add_array(
                 via_type, columns=nb_vias_x, rows=1, spacing=(pitch_x, pitch_y)
             )
             ref.center = pos
 
             # Place top and bottom metal
             for metal in [metal_top, metal_bottom]:
                 met = c << gf.components.rectangle(size=size_metal, layer=metal)
                 met.center = pos
 
             # Let's see if we can do something different
             x, y = pos
-            print(f"x={x}, y={y}")
 
             if x > 0:
                 new_y = y + pitch_y
                 mult = 1
             else:
                 new_y = y - pitch_y
                 mult = -1
 
             if new_y > radius:
                 new_y = y - pitch_y
                 assert new_y < radius
                 new_x = -1 * np.sqrt(np.power(radius, 2) - np.power(new_y, 2))
             elif new_y < -radius:
                 new_y = y + pitch_y
                 assert new_y > -radius
                 new_x = np.sqrt(np.power(radius, 2) - np.power(new_y, 2))
 
             else:
                 new_x = mult * np.sqrt(np.power(radius, 2) - np.power(new_y, 2))
 
             if np.isnan(new_x):
                 print(radius)
                 print(new_y)
                 print(np.power(radius, 2) - np.power(new_y, 2))
             assert not np.isnan(new_x)
-
-            print(f"new x={new_x}, new y={new_y}")
             ang = np.arctan2(new_y, new_x)
-            print(f"new angle = {ang * 180 / np.pi}")
-
-            # input()
-
-        print("LAYER DONE")
 
     return c
 
 
 def _smaller_angle(angle, angle1, angle2):
@@ -253,18 +243,18 @@
 
     if angle2 >= 0 and angle1 >= 0:
         if angle2 > angle1:
             return angle < angle2
         # Convert angle to 0, 2pi and see if out of bounds
         angle = angle + 2 * np.pi * (angle < 0)
         return not (angle2 < angle < angle1)
 
     elif angle2 < 0 and angle1 < 0:
         return angle < angle2 if angle2 > angle1 else not (angle2 < angle < angle1)
     else:
         if angle2 < 0 and angle > 0 or angle2 >= 0 and angle < 0:
             return True
         else:
             return angle < angle2
 
 
 @gf.cell
@@ -280,7 +270,8 @@
 ) -> Component:
     """Rectangular via array stack, with optimized dimension for vias.
 
-    Uses inclusion, minimum width, and minimum spacing rules to place the maximum number of individual vias, each with maximum via area.
+    Uses inclusion, minimum width, and minimum spacing rules to place the maximum number of individual vias,
+    each with maximum via area.
 
     Args:
         size: of the layers, len(size).
@@ -444,15 +435,17 @@
 
 
 if __name__ == "__main__":
-    c = via_stack_m1_m3(size=(1.0, 1.0))
+    c = via_stack_heater_mtop(layer_offsets=(0, 1, 2))
+
+    # c = via_stack_circular()
+    # c = via_stack_m1_m3(size=(1.0, 1.0))
     # print(c.to_dict())
-    c.show(show_ports=True)
+    # c.show(show_ports=True)
 
     # c = via_stack_from_rules()
-    # c = via_stack_heater_mtop()
     # c.show(show_ports=True)
 
-    # c = circular_via_stack(
+    # c = via_stack_circular(
     #     radius=20.0,
     #     angular_extent=300,
     #     center_angle=0,
@@ -461,6 +454,4 @@
     #     vias=(via1, via2),
     #     layer_port=None,
     # )
-    # c.show()
-
-    # test_via_stack_from_rules()
+    c.show(show_ports=True)

gdsfactory/components/via_stack_with_offset.py

@@ -7,38 +7,40 @@
 import gdsfactory as gf
 from gdsfactory.component import Component
 from gdsfactory.components.via import viac
-from gdsfactory.typings import ComponentSpec, LayerSpecs
+from gdsfactory.components.compass import compass
+from gdsfactory.typings import ComponentSpec, LayerSpecs, Float2
 
 
 @gf.cell
 def via_stack_with_offset(
     layers: LayerSpecs = ("PPP", "M1"),
-    sizes: Tuple[Tuple[float, float], ...] = ((10, 10), (10, 10)),
+    size: Float2 = (10, 10),
+    sizes: Optional[Tuple[Float2, ...]] = None,
     vias: Tuple[Optional[ComponentSpec], ...] = (None, viac),
     offsets: Optional[Tuple[float, ...]] = None,
-    port_orientation: float = 180,
 ) -> Component:
     """Rectangular layer transition with offset between layers.
 
     Args:
         layers: for each via.
-        vias: factory for via or None for no via.
-        sizes: for each via.
-        offsets: for next layer.
-        port_orientation: 180: W0, 0: E0, 90: N0, 270: S0.
+        size: for all vias.
+        sizes: Optional size for each via. Overrides size.
+        vias: factory for each via. None for no via.
+        offsets: center offset for each layer relatively to the previous one.
     """
     c = Component()
-    y0 = y1 = 0
+    y0 = 0
 
     offsets = offsets or [0] * len(layers)
+    sizes = sizes or [size] * len(layers)
 
     for layer, via, size, offset in zip(layers, vias, sizes, offsets):
         width, height = size
         x0 = -width / 2
-        x1 = +width / 2
-        y1 = y0 + height
-        rect_pts = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
-        c.add_polygon(rect_pts, layer=layer)
+        ref_layer = c << compass(
+            size=(width, 2 * height), layer=layer, port_type="electrical"
+        )
+        ref_layer.ymin = y0
 
         if via:
             via = gf.get_component(via)
@@ -64,24 +66,8 @@ def via_stack_with_offset(
             ref.move((x00, y00))
 
         y0 += offset
-        y1 = y0 + height
-        rect_pts = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
-        c.add_polygon(rect_pts, layer=layer)
-
-    port_width = height if port_orientation in {0, 180} else width
 
-    if port_orientation not in [0, 90, 270, 180]:
-        raise ValueError(
-            f"Invalid port_orientation = {port_orientation} not in [0, 90, 180, 270]"
-        )
-    c.add_port(
-        name="e1",
-        width=port_width,
-        orientation=port_orientation,
-        center=(0, y1),
-        port_type="electrical",
-        layer=list(layers)[-1],
-    )
+    c.add_ports(ref_layer.ports)
     return c
 
 
@@ -91,11 +77,24 @@ def via_stack_with_offset(
     vias=(None, viac),
 )
 
+via_stack_with_offset_ppp_m1 = gf.partial(
+    via_stack_with_offset,
+    layers=("PPP", "M1"),
+    vias=(None, viac),
+)
+
+via_stack_with_offset_m1_m3 = gf.partial(
+    via_stack_with_offset,
+    layers=("M1", "M2", "M3"),
+    vias=("via1", "via2", None),
+)
+
 
 if __name__ == "__main__":
-    c = via_stack_with_offset_ppp_m1(
-        layers=("SLAB90", "M1"),
-        sizes=((20, 10), (20, 10)),
-        vias=(viac(size=(18, 2), spacing=(5, 5)), None),
-    )
+    # c = via_stack_with_offset_ppp_m1(
+    #     layers=("SLAB90", "M1"),
+    #     sizes=((20, 10), (20, 10)),
+    #     vias=(viac(size=(18, 2), spacing=(5, 5)), None),
+    # )
+    c = via_stack_with_offset_m1_m3(offsets=(5, 5, 5))
     c.show(show_ports=True)

gdsfactory/generic_tech/klayout/tech/layers.lyp

@@ -73,7 +73,7 @@
   <fill-color>#805000</fill-color>
   <frame-brightness>0</frame-brightness>
   <fill-brightness>0</fill-brightness>
-  <dither-pattern>I1</dither-pattern>
+  <dither-pattern>I3</dither-pattern>
   <line-style/>
   <valid>true</valid>
   <visible>true</visible>

gdsfactory/generic_tech/layer_views.yaml

@@ -26,7 +26,7 @@ LayerViews:
   SLAB90:
     layer: [3, 0]
     layer_in_name: true
-    hatch_pattern: hollow
+    hatch_pattern: coarsely dotted
     transparent: true
     width: 1
     color: "#805000"

tests/test_components.py

@@ -17,6 +17,7 @@
     "pack_doe_grid",
     "crossing",
     "spiral_racetrack",
+    "ring_section_based",
 }
 
 

tests/test_components/test_settings_via_stack_with_offset_.yml

@@ -2,7 +2,7 @@ name: via_stack_with_offset
 ports:
   e1:
     center:
-    - 0.0
+    - -5.0
     - 10.0
     layer:
     - 41
@@ -11,6 +11,42 @@ ports:
     orientation: 180
     port_type: electrical
     shear_angle: null
+    width: 20
+  e2:
+    center:
+    - 0.0
+    - 20.0
+    layer:
+    - 41
+    - 0
+    name: e2
+    orientation: 90
+    port_type: electrical
+    shear_angle: null
+    width: 10
+  e3:
+    center:
+    - 5.0
+    - 10.0
+    layer:
+    - 41
+    - 0
+    name: e3
+    orientation: 0.0
+    port_type: electrical
+    shear_angle: null
+    width: 20
+  e4:
+    center:
+    - 0.0
+    - 0.0
+    layer:
+    - 41
+    - 0
+    name: e4
+    orientation: 270
+    port_type: electrical
+    shear_angle: null
     width: 10
 settings:
   changed: {}
@@ -20,12 +56,10 @@ settings:
     - PPP
     - M1
     offsets: null
-    port_orientation: 180
-    sizes:
-    - - 10
-      - 10
-    - - 10
-      - 10
+    size:
+    - 10
+    - 10
+    sizes: null
     vias:
     - null
     - function: via
@@ -36,12 +70,10 @@ settings:
     - PPP
     - M1
     offsets: null
-    port_orientation: 180
-    sizes:
-    - - 10
-      - 10
-    - - 10
-      - 10
+    size:
+    - 10
+    - 10
+    sizes: null
     vias:
     - null
     - function: via