gplugins 0.10.2__tar.gz → 0.12.0__tar.gz

{gplugins-0.10.2 → gplugins-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gplugins
-Version: 0.10.2
+Version: 0.12.0
 Summary: gdsfactory plugins
 Keywords: python
 Author-email: gdsfactory <contact@gdsfactory.com>
@@ -46,12 +46,14 @@ Requires-Dist: shapely ; extra == "gmsh"
 Requires-Dist: meshwell>=1.0.7,<=1.1 ; extra == "gmsh"
 Requires-Dist: klayout ; extra == "klayout"
 Requires-Dist: pyvis<=0.3.1 ; extra == "klayout"
-Requires-Dist: jax==0.4.23 ; extra == "meow"
-Requires-Dist: jaxlib==0.4.23 ; extra == "meow"
-Requires-Dist: meow-sim>=0.9.0,<0.10.2 ; extra == "meow"
+Requires-Dist: jax>=0.4.26 ; extra == "meow"
+Requires-Dist: jaxlib>=0.4.26 ; extra == "meow"
+Requires-Dist: flax>=0.8.2 ; extra == "meow"
+Requires-Dist: meow-sim>=0.9.0,<0.12.0 ; extra == "meow"
 Requires-Dist: tidy3d==2.5.2 ; extra == "meow"
-Requires-Dist: jax<=0.4.23 ; extra == "sax"
-Requires-Dist: jaxlib<=0.4.23 ; extra == "sax"
+Requires-Dist: jax>=0.4.26 ; extra == "sax"
+Requires-Dist: jaxlib>=0.4.26 ; extra == "sax"
+Requires-Dist: flax>=0.8.2 ; extra == "sax"
 Requires-Dist: sax>=0.12.1,<0.13.0 ; extra == "sax"
 Requires-Dist: scikit-learn ; extra == "sax"
 Requires-Dist: pyvis<=0.3.1 ; extra == "sax"
@@ -75,7 +77,7 @@ Provides-Extra: schematic
 Provides-Extra: tidy3d
 Provides-Extra: vlsir
 
-# gplugins 0.10.2
+# gplugins 0.12.0
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)

{gplugins-0.10.2 → gplugins-0.12.0}/README.md

@@ -1,4 +1,4 @@
-# gplugins 0.10.2
+# gplugins 0.12.0
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/__init__.py

@@ -1,6 +1,6 @@
 """gplugins - gdsfactory plugins"""
 
-__version__ = "0.10.2"
+__version__ = "0.12.0"
 
 from gplugins.common.utils import plot, port_symmetries
 from gplugins.common.utils.get_effective_indices import get_effective_indices

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/add_simulation_markers.py

@@ -1,4 +1,5 @@
 """Returns component with simulation markers."""
+
 from __future__ import annotations
 
 import warnings

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/async_helpers.py

@@ -18,9 +18,11 @@ async def handle_return(
     append: bool = False,
 ) -> None:
     """Reads through a :class:`StreamReader` and tees content to ``out_stream`` and ``log_file``."""
-    with open(
-        log_file, "a" if append else "w", encoding="utf-8", buffering=1
-    ) if log_file else nullcontext(None) as f:
+    with (
+        open(log_file, "a" if append else "w", encoding="utf-8", buffering=1)
+        if log_file
+        else nullcontext(None) as f
+    ):
         while True:
             # Without this sleep, the program won't exit
             await asyncio.sleep(0)

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/disable_print.py

@@ -1,4 +1,5 @@
 """Disable print statements for overly verbose simulators."""
+
 from __future__ import annotations
 
 import os

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/get_component_with_net_layers.py

@@ -88,9 +88,9 @@ def get_component_with_net_layers(
                             new_layers_init[0] + i,
                             new_layers_init[1] + j,
                         )
-                        layer_stack.layers[
-                            f"{old_layername}{delimiter}{portname}"
-                        ] = new_layer
+                        layer_stack.layers[f"{old_layername}{delimiter}{portname}"] = (
+                            new_layer
+                        )
                     net_component.add_polygon(polygon, layer=new_layer_number)
             # Otherwise put the polygon back on the same layer
             else:

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/optical_constants.py

@@ -1,4 +1,5 @@
 """Useful optical constant manipulations."""
+
 import numpy as np
 
 

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/common/utils/parse_layer_stack.py

@@ -1,4 +1,5 @@
 """Preprocessing involving only the LayerStack."""
+
 from __future__ import annotations
 
 import numpy as np

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/devsim/get_simulation_xsection.py

@@ -8,7 +8,6 @@ From Chrostowski, L., & Hochberg, M. (2015). Silicon Photonics Design: From Devi
 
 """
 
-
 from __future__ import annotations
 
 import warnings
@@ -57,8 +56,8 @@ def dn_carriers(wavelength: float, dN: float, dP: float) -> float:
     else:
         wavelength *= 1e-6
         return (
-            -3.64 * 1e-10 * wavelength**2 * dN
-            - 3.51 * 1e-6 * wavelength**2 * np.power(dP, 0.8)
+            -3.64 * 1e-10 * wavelength** 2 * dN
+            - 3.51 * 1e-6 * wavelength** 2 * np.power(dP, 0.8)
         )
 
 

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/femwell/solve_thermal.py

@@ -45,16 +45,16 @@ def get_thermal_conductivities(basis):
         # adding the layer to the thermal_conductivities dict. Check for that
         # case
         if domain in thermal_conductivities:
-            thermal_conductivity[
-                basis.get_dofs(elements=domain)
-            ] = thermal_conductivities[domain]
+            thermal_conductivity[basis.get_dofs(elements=domain)] = (
+                thermal_conductivities[domain]
+            )
         else:
             for material, labels in materials_dict.items():
                 if domain in labels:
                     # Assign the right values
-                    thermal_conductivity[
-                        basis.get_dofs(elements=domain)
-                    ] = thermal_conductivities[material]
+                    thermal_conductivity[basis.get_dofs(elements=domain)] = (
+                        thermal_conductivities[material]
+                    )
                     break
 
     thermal_conductivity *= 1e-12  # 1e-12 -> conversion from 1/m^2 -> 1/um^2

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/gmeep/get_simulation.py

@@ -1,4 +1,5 @@
 """Returns simulation from component."""
+
 from __future__ import annotations
 
 import inspect

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/gmeep/get_simulation_grating_farfield.py

@@ -7,6 +7,7 @@
 - add tests
 
 """
+
 from __future__ import annotations
 
 from typing import Any

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/gmeep/write_sparameters_grating.py

@@ -6,6 +6,7 @@ MFD:
 - 9.2 for Oband
 
 """
+
 from __future__ import annotations
 
 import hashlib

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/gmsh/parse_component.py

@@ -1,4 +1,5 @@
 """Preprocessing involving both the GDS and the LayerStack, or the resulting simulation polygons."""
+
 from __future__ import annotations
 
 import numpy as np
@@ -75,15 +76,15 @@ def process_buffers(layer_polygons_dict: dict, layer_stack: LayerStack):
                         layer_stack.layers[layername].thickness * zs[z_ind + 1]
                         - layer_stack.layers[layername].thickness * z
                     )
-                    extended_layer_stack_layers[
-                        f"{layername}_{poly_ind}_{z}"
-                    ] = LayerLevel(
-                        layer=layer_stack.layers[layername].layer,
-                        thickness=new_thickness,
-                        zmin=new_zmin,
-                        material=layer_stack.layers[layername].material,
-                        info=layer_stack.layers[layername].info,
-                        mesh_order=layer_stack.layers[layername].mesh_order,
+                    extended_layer_stack_layers[f"{layername}_{poly_ind}_{z}"] = (
+                        LayerLevel(
+                            layer=layer_stack.layers[layername].layer,
+                            thickness=new_thickness,
+                            zmin=new_zmin,
+                            material=layer_stack.layers[layername].material,
+                            info=layer_stack.layers[layername].info,
+                            mesh_order=layer_stack.layers[layername].mesh_order,
+                        )
                     )
                     extended_layer_polygons_dict[f"{layername}_{poly_ind}_{z}"] = (
                         f"{layername}",
@@ -91,16 +92,16 @@ def process_buffers(layer_polygons_dict: dict, layer_stack: LayerStack):
                         polygon.buffer(width_buffer),
                         polygon.buffer(width_buffers[z_ind + 1]),
                     )
-                extended_layer_stack_layers[
-                    f"{layername}_{poly_ind}_{zs[-1]}"
-                ] = LayerLevel(
-                    layer=layer_stack.layers[layername].layer,
-                    thickness=0,
-                    zmin=layer_stack.layers[layername].zmin
-                    + layer_stack.layers[layername].thickness,
-                    material=layer_stack.layers[layername].material,
-                    info=layer_stack.layers[layername].info,
-                    mesh_order=layer_stack.layers[layername].mesh_order,
+                extended_layer_stack_layers[f"{layername}_{poly_ind}_{zs[-1]}"] = (
+                    LayerLevel(
+                        layer=layer_stack.layers[layername].layer,
+                        thickness=0,
+                        zmin=layer_stack.layers[layername].zmin
+                        + layer_stack.layers[layername].thickness,
+                        material=layer_stack.layers[layername].material,
+                        info=layer_stack.layers[layername].info,
+                        mesh_order=layer_stack.layers[layername].mesh_order,
+                    )
                 )
     return extended_layer_polygons_dict, LayerStack(layers=extended_layer_stack_layers)
 

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/gmsh/parse_gds.py

@@ -1,4 +1,5 @@
 """Preprocessing involving mostly the GDS polygons."""
+
 from __future__ import annotations
 
 import gdsfactory as gf
@@ -39,7 +40,7 @@ def fuse_polygons(
     ]
 
     return shapely.ops.unary_union(shapely_polygons).simplify(
-        simplify_tol, preserve_topology=True
+        simplify_tol, preserve_topology=False
     )
 
 

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/klayout/dataprep/regions.py

@@ -95,6 +95,7 @@ class RegionCollection:
         self.layout = lib.cell_by_name(cell_name) if cell_name else lib.top_cell()
         self.lib = lib
         self.regions = {}
+        self.cell = lib[lib.top_cell().cell_index()]
 
     def __getitem__(self, layer: tuple[int, int]) -> Region:
         _assert_is_layer(layer)
@@ -142,13 +143,9 @@ class RegionCollection:
         else:
             c.write(gdspath)
 
-    def plot(self, **kwargs):
+    def plot(self) -> kf.KCell:
         """Plot regions."""
-        gdspath = GDSDIR_TEMP / "out.gds"
-        self.write_gds(gdspath=gdspath, **kwargs)
-        gf.clear_cache()
-        c = gf.import_gds(gdspath)
-        return c.plot()
+        return self.cell
 
     def get_kcell(
         self, keep_original: bool = True, cellname: str = "Unnamed"

{gplugins-0.10.2 → gplugins-0.12.0}/gplugins/klayout/drc/samples/drc_errors.py

@@ -1,22 +1,23 @@
 """Write GDS with sample errors."""
+
 from __future__ import annotations
 
 import gdsfactory as gf
+import numpy as np
 from gdsfactory.component import Component
-from gdsfactory.typings import Float2, Layer
+from gdsfactory.typings import Layer
 
 layer = (1, 0)
 
 
 @gf.cell
-def width_min(size: Float2 = (0.1, 0.1)) -> Component:
-    return gf.components.rectangle(size=size, layer=layer)
+def width_min(width: float = 0.1) -> Component:
+    return gf.components.rectangle(size=(width, width), layer=layer)
 
 
 @gf.cell
-def area_min() -> Component:
-    size = (0.2, 0.2)
-    return gf.components.rectangle(size=size, layer=layer)
+def area_min(width: float = 0.2) -> Component:
+    return gf.components.rectangle(size=(width, width), layer=layer)
 
 
 @gf.cell
@@ -46,8 +47,13 @@ def enclosing(
     enclosing: float = 0.1, layer1: Layer = (40, 0), layer2: Layer = (41, 0)
 ) -> Component:
     """Layer1 must be enclosed by layer2 by value.
-
     checks if layer1 encloses (is bigger than) layer2 by value
+
+    Args:
+        enclosing: value to enclose layer1 by layer2.
+        layer1: layer to enclose.
+        layer2: layer to enclose by.
+
     """
     w1 = 1
     w2 = w1 + enclosing
@@ -69,18 +75,17 @@ def snapping_error(gap: float = 1e-3) -> Component:
 
 
 @gf.cell
-def errors() -> Component:
-    """Write a GDS with sample errors."""
-    components = [width_min(), gap_min(), separation(), enclosing()]
-    c = gf.pack(components, spacing=1.5)
-    return gf.add_padding_container(c[0], layers=((64, 0),), default=5)
-
-
-@gf.cell
-def errors2() -> Component:
+def errors(n: int = 20) -> Component:
     """Write a GDS with sample errors."""
-    components = 2 * [width_min(), gap_min(), separation(), enclosing()]
-    c = gf.pack(components, spacing=1.5)
+    wmin = 0.1
+    # components = [width_min(), gap_min(), separation(), enclosing()]
+    cs = []
+    cs += [width_min(wmin * np.random.rand()) for _ in range(n)]
+    cs += [gap_min(gap=0.1 * np.random.rand()) for _ in range(n)]
+    cs += [separation(gap=0.1 * np.random.rand()) for _ in range(n)]
+    cs += [enclosing(enclosing=0.1 * np.random.rand()) for _ in range(n)]
+
+    c = gf.pack(cs, spacing=1.5)
     return gf.add_padding_container(c[0], layers=((64, 0),), default=5)
 
 
@@ -92,6 +97,6 @@ if __name__ == "__main__":
     # c = snapping_error()
     # c.write_gds("snap.gds")
 
-    c = errors2()
+    c = errors()
     c.write_gds("errors.gds")
     c.show(show_ports=True)

gplugins-0.12.0/gplugins/klayout/netlist_graph.py

@@ -0,0 +1,137 @@
+import itertools
+from pathlib import Path
+
+import klayout.db as kdb
+import networkx as nx
+from gdsfactory.config import logger
+from gdsfactory.typings import PathType
+
+from gplugins.klayout.netlist_spice_reader import (
+    CalibreSpiceReader,
+    NetlistSpiceReaderDelegateWithStrings,
+)
+
+
+def _get_device_name(device: kdb.Device) -> str:
+    """Get a unique name for a ``Device`` instance."""
+    return f"{device.device_class().name}_{device.expanded_name()}"
+
+
+def netlist_to_networkx(
+    netlist: kdb.Netlist,
+    include_labels: bool = True,
+    top_cell: str | None = None,
+    spice_reader_instance: NetlistSpiceReaderDelegateWithStrings | None = None,
+) -> nx.Graph:
+    """Convert a KLayout DB `Netlist` to a networkx graph.
+
+    Args:
+        netlist: The KLayout DB `Netlist` to convert to a NetworkX `Graph`.
+        include_labels: Whether to include net labels in the graph connected to corresponding cells.
+        top_cell: The name of the top cell to consider for the NetworkX graph. Defaults to all top cells.
+        spice_reader_instance: The KLayout Spice reader that was used for parsing SPICE netlists.
+            Used for fetching string parameter values from a stored mapping.
+
+    Returns:
+        A networkx `Graph` representing the connectivity of the `Netlist`.
+    """
+    G = nx.Graph()
+    netlist.flatten()
+
+    top_circuits = list(
+        itertools.islice(netlist.each_circuit_top_down(), netlist.top_circuit_count())
+    )
+
+    if top_cell:
+        try:
+            top_circuits = (
+                next(
+                    c for c in top_circuits if c.name.casefold() == top_cell.casefold()
+                ),
+            )
+        except StopIteration as e:
+            available_top_cells = [cell.name for cell in top_circuits]
+            raise ValueError(
+                f"{top_cell=!r} not found in the netlist. Available top cells: {available_top_cells!r}"
+            ) from e
+
+    all_used_nets = set()
+    for circuit in top_circuits:
+        for device in circuit.each_device():
+            # Gather properties of Device class
+            device_class = device.device_class()
+            parameter_definitions = device_class.parameter_definitions()
+            terminal_definitions = device_class.terminal_definitions()
+
+            # Gather values for specific Device instance
+            parameters = {
+                parameter.name: (
+                    spice_reader_instance.integer_to_string_map.get(
+                        int(device.parameter(parameter.name)),
+                        device.parameter(parameter.name),
+                    )
+                    if spice_reader_instance
+                    else device.parameter(parameter.name)
+                )
+                for parameter in parameter_definitions
+            }
+            nets = [
+                device.net_for_terminal(terminal.name)
+                for terminal in terminal_definitions
+            ]
+            device_name = _get_device_name(device)
+
+            # Create NetworkX representation
+            G.add_node(device_name, **parameters)
+            for net in nets:
+                net_name = net.expanded_name()
+                G.add_edge(device_name, net_name)
+                all_used_nets.add(net_name)
+
+    if not include_labels:
+        for node in all_used_nets:
+            connections = list(G.neighbors(node))
+            G.add_edges_from(itertools.combinations(connections, r=2))
+            G.remove_node(node)
+
+    return G
+
+
+def networkx_from_spice(
+    filepath: PathType,
+    include_labels: bool = True,
+    top_cell: str | None = None,
+    spice_reader: type[NetlistSpiceReaderDelegateWithStrings] = CalibreSpiceReader,
+    **kwargs,
+) -> nx.Graph:
+    """Returns a networkx Graph from a SPICE netlist file or KLayout LayoutToNetlist.
+    Args:
+        filepath: Path to the KLayout LayoutToNetlist file or a SPICE netlist.
+            File extensions should be `.l2n` and `.spice`, respectively.
+        include_labels: Whether to include labels in the graph connected to corresponding cells.
+        top_cell: The name of the top cell to consider for the NetworkX graph. Defaults to all top cells.
+        spice_reader: The KLayout Spice reader to use for parsing SPICE netlists.
+    """
+    spice_reader_instance = None
+    match Path(filepath).suffix:
+        case ".l2n" | ".txt":
+            l2n = kdb.LayoutToNetlist()
+            l2n.read(str(filepath))
+            netlist = l2n.netlist()
+        case ".cir" | ".sp" | ".spi" | ".spice":
+            reader = kdb.NetlistSpiceReader(spice_reader_instance := spice_reader())
+            netlist = kdb.Netlist()
+            netlist.read(str(filepath), reader)
+        case _:
+            logger.warning("Assuming file is KLayout native LayoutToNetlist file")
+            l2n = kdb.LayoutToNetlist()
+            l2n.read(str(filepath))
+            netlist = l2n.netlist()
+
+    # Creating a graph for the connectivity
+    return netlist_to_networkx(
+        netlist,
+        include_labels=include_labels,
+        top_cell=top_cell,
+        spice_reader_instance=spice_reader_instance,
+    )

gplugins-0.12.0/gplugins/klayout/netlist_spice_reader.py

@@ -0,0 +1,117 @@
+import hashlib
+import re
+from abc import ABC, abstractmethod
+from collections.abc import MutableMapping, Sequence
+from typing import Any
+
+import klayout.db as kdb
+
+
+class NetlistSpiceReaderDelegateWithStrings(kdb.NetlistSpiceReaderDelegate, ABC):
+    """A KLayout SPICE reader delegate that supports string variables for ``Device`` through a hash map."""
+
+    @property
+    @abstractmethod
+    def integer_to_string_map(self) -> MutableMapping[int, str]:
+        pass
+
+
+class NoCommentReader(kdb.NetlistSpiceReaderDelegate):
+    """KLayout Spice reader without comments after $. This allows checking the netlist for HSPICE."""
+
+    n_nodes: int = 0
+
+    def parse_element(self, s: str, element: str) -> kdb.ParseElementData:
+        if "$" in s:
+            s, *_ = s.split("$")  # Don't take comments into account
+        parsed = super().parse_element(s, element)
+        # ensure uniqueness
+        parsed.model_name = parsed.model_name + f"_{self.n_nodes}"
+        self.n_nodes += 1
+        return parsed
+
+
+class CalibreSpiceReader(NetlistSpiceReaderDelegateWithStrings):
+    """KLayout Spice reader for Calibre LVS extraction output.
+
+    Considers parameter values for generic `X` devices that start with `WG`.
+    Ignores comments after $ excluding location given with ``$X=number $Y=number``."""
+
+    n_nodes: int = 0
+    calibre_location_pattern: str = r"\$X=(-?\d+) \$Y=(-?\d+)"
+    integer_to_string_map: MutableMapping[int, str] = {}
+
+    def wants_subcircuit(self, name: str):
+        """Model all SPICE models that start with `WG` as devices in order to support parameters."""
+        return "WG" in name or super().wants_subcircuit(name)
+
+    def parse_element(self, s: str, element: str) -> kdb.ParseElementData:
+        x_value, y_value = None, None
+        if "$" in s:
+            if location_matches := re.search(self.calibre_location_pattern, s):
+                x_value, y_value = (int(e) / 1000 for e in location_matches.group(1, 2))
+
+            # Use default KLayout parser for rest of the SPICE
+            s, *_ = s.split("$")
+
+        parsed = super().parse_element(s, element)
+        parsed.parameters |= {"x": x_value, "y": y_value}
+
+        # ensure uniqueness
+        parsed.model_name = parsed.model_name
+        self.n_nodes += 1
+        return parsed
+
+    @staticmethod
+    def hash_str_to_int(s: str) -> int:
+        return int(hashlib.shake_128(s.encode()).hexdigest(4), 16)
+
+    def element(
+        self,
+        circuit: kdb.Circuit,
+        element: str,
+        name: str,
+        model: str,
+        value: Any,
+        nets: Sequence[kdb.Net],
+        parameters: dict[str, int | float | str],
+    ):
+        # Handle non-'X' elements with standard KLayout processing
+        if element != "X":
+            # Other devices with standard KLayout
+            return super().element(
+                circuit, element, name, model, value, nets, parameters
+            )
+        clx = circuit.netlist().device_class_by_name(model)
+
+        # Create Device class on first occurrence
+        if not clx:
+            clx = kdb.DeviceClass()
+            clx.name = model
+            for key, value in parameters.items():
+                clx.add_parameter(kdb.DeviceParameterDefinition(key))
+                # map string variables to integers
+                if (
+                    isinstance(value, str)
+                    and value not in self.integer_to_string_map.values()
+                ):
+                    hashed_value = CalibreSpiceReader.hash_str_to_int(value)
+                    self.integer_to_string_map[hashed_value] = value
+
+            for i in range(len(nets)):
+                clx.add_terminal(kdb.DeviceTerminalDefinition(str(i)))
+            circuit.netlist().add(clx)
+
+        device = circuit.create_device(clx, name)
+        for i, net in enumerate(nets):
+            device.connect_terminal(i, net)
+
+        for key, value in parameters.items():
+            device.set_parameter(
+                key,
+                (
+                    CalibreSpiceReader.hash_str_to_int(value)
+                    if isinstance(value, str)
+                    else value
+                ),
+            )