gdsfill 0.1.0__tar.gz

gdsfill-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: gdsfill
+Version: 0.1.0
+Summary: A Python project using pyyaml, packaging, and gdstk.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: homepage, https://example.com
+Project-URL: repository, https://github.com/yourusername/my-python-project
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml
+Requires-Dist: packaging
+Requires-Dist: gdstk

gdsfill-0.1.0/README.rst

@@ -0,0 +1,98 @@
+gdsfill
+=======
+
+**gdsfill** is an open-source tool for inserting dummy metal fill into semiconductor layouts.
+It helps designers meet density requirements and prepare GDSII layouts for manufacturing by analyzing, erasing, and generating dummy fill patterns across multiple layers.
+The tool is designed to integrate easily into existing design flows and ensures reproducible, automated preparation of layouts before tape-out.
+
+This project is still under development. Please report any issues you encounter and always verify your layout before tape-out deadlines to prevent submission failures.
+
+Installation
+############
+
+**gdsfill** can be installed as a Python package. We recommend using a virtual environment to keep dependencies isolated.
+
+.. code-block:: text
+
+   $ python3 -m venv venv
+   $ source venv/bin/activate
+   (venv) $ pip install --updage pip
+   (venv) $ pip install gdsfill
+
+Density
+#######
+
+This command calculates the utilization per layer and prints the values.
+It is useful to check layer density before and after running the fill process:
+
+.. code-block:: text
+
+   gdsfill density <my-layout.gds>
+
+Erase
+#####
+
+If a layout already contains dummy fill, or if previous fills should be removed, this command erases all dummy metal fill from a layout:
+
+.. code-block:: text
+
+   gdsfill erase <my-layout.gds>
+
+Fill
+####
+
+To insert dummy metal fill into all supported layers of a layout, run:
+
+.. code-block:: text
+
+   gdsfill fill <my-layout.gds>
+
+Some algorithms, such as the track filler, require information about the chip core region. You can provide the lower-left and upper-right coordinates as floating-point values:
+
+.. code-block:: text
+
+   gdsfill fill <my-layout.gds> --core-size llx lly urx ury
+
+By default, **gdsfill** creates a temporary directory for intermediate data.
+Use ``--keep-data`` to retain all generated files in a directory called ``gdsfill-tmp``:
+
+.. code-block:: text
+
+   gdsfill fill <my-layout.gds> --keep-data
+
+If you only want to simulate the process without modifying the layout file, use ``--dry-run``:
+
+.. code-block:: text
+
+   gdsfill fill <my-layout.gds> --dry-run
+
+
+Custom Configuration
+####################
+
+By default, **gdsfill** inserts dummy metal fill into each layer using predefined parameters.
+To apply different parameters or restrict fill to specific layers, you can create a custom configuration file.
+
+The following example config inserts fill only into **TopMetal1** and **TopMetal2**:
+
+.. code-block:: yaml
+
+   PDK: ihp-sg13g2
+   layers:
+     TopMetal1:
+       algorithm: Square
+       density: 60
+       deviation: 1
+     TopMetal2:
+       algorithm: Square
+       density: 60
+       deviation: 1
+
+.. note::
+   Example config files are available in ``gdsfill/configs``.
+
+To use a custom config file, pass it with ``--config-file``:
+
+.. code-block:: text
+
+   gdsfill fill <my-layout.gds> --config-file <my-config-file.yaml>

gdsfill-0.1.0/gdsfill/gdsfill.py

@@ -0,0 +1,211 @@
+"""
+Command-line interface for GDSII dummy fill operations.
+
+This module provides subcommands to:
+- Insert dummy fill into a layout (`fill`)
+- Erase dummy fill from a layout (`erase`)
+- Calculate per-layer density (`density`)
+
+Dummy fill is generated tile-by-tile using processes defined
+in the PDK, and relies on Klayout for GDSII operations.
+"""
+
+import argparse
+import tempfile
+import importlib
+from pathlib import Path
+from multiprocessing import Process
+
+from gdsfill.library.klayout import (
+  get_version,
+  export_layer,
+  print_density,
+  erase_fill,
+  merge_tile
+)
+from gdsfill.library.common import (
+  PdkInformation,
+  Tile,
+  open_yaml
+)
+from gdsfill.library.fill import fill_layer
+
+
+# pylint: disable=too-many-locals, too-many-arguments, too-many-positional-arguments
+def _fill_layer(layer, pdk, inputfile, tmpdirname, dry_run, core_size=None):
+    """
+    Run the fill pipeline for a single layer.
+
+    Steps:
+      1. Export layer geometry into tiles.
+      2. Modify tiles using the process-specific `prepare_tile`.
+      3. Apply dummy fill to each tile with the selected algorithms.
+      4. Optionally merge tiles back into a single GDS file.
+
+    Args:
+        layer (str): Target layer name.
+        pdk (PdkInformation): PDK instance with layer rules.
+        inputfile (Path): Path to the input GDS file.
+        tmpdirname (Path | str): Temporary directory for intermediate data.
+        dry_run (bool): If True, skip merging filled tiles.
+
+    Returns:
+        None
+    """
+    print(f"--- Layer {layer} ---")
+
+    output_path = Path(tmpdirname) / layer
+    for stage in ('raw', 'modified', 'filled'):
+        (output_path / stage).mkdir(parents=True, exist_ok=True)
+
+    export_layer(pdk, inputfile, output_path, layer, core_size)
+    tiles = open_yaml(output_path / "tiles.yaml")
+
+    prepare_module = importlib.import_module(f'gdsfill.{pdk.get_name()}.prepare')
+    procs_modify = []
+    for tile in tiles['tiles'].keys():
+        raw_tile = output_path / "raw" / f"tile_{tile}.gds"
+        proc = Process(target=prepare_module.prepare_tile, args=(pdk, raw_tile, layer))
+        procs_modify.append(proc)
+        proc.start()
+    for proc in procs_modify:
+        proc.join()
+
+    procs_fill = []
+    for tile, values in tiles['tiles'].items():
+        file = output_path / "modified" / f"tile_{tile}.gds"
+        proc = Process(target=fill_layer,
+                       args=(pdk, file, layer, tiles, Tile(values['x'], values['y'])))
+        procs_fill.append(proc)
+        proc.start()
+    for proc in procs_fill:
+        proc.join()
+
+    if dry_run:
+        print("Skip merging filled tiles because --dry-run was passed.")
+    else:
+        merge_tile(pdk, inputfile, output_path / "filled", output_path / "tiles.yaml")
+
+
+def func_fill(args, pdk):
+    """
+    Subcommand: Insert dummy fill into each layer of a GDS file.
+
+    Args:
+        args (Namespace): Parsed CLI arguments.
+        pdk (PdkInformation): PDK instance with layer rules.
+
+    Returns:
+        None
+    """
+    if args.keep_data:
+        tmpdirname = Path.cwd() / "gdsfill-tmp"
+        print(f"Data are stored in {tmpdirname}")
+        for layer, _ in pdk.get_layers():
+            _fill_layer(layer, pdk, args.input, tmpdirname, args.dry_run, args.core_size)
+    else:
+        with tempfile.TemporaryDirectory(prefix='gdsfill-') as tmpdirname:
+            for layer, _ in pdk.get_layers():
+                _fill_layer(layer, pdk, args.input, tmpdirname, args.dry_run, args.core_size)
+
+
+def func_density(args, pdk):
+    """
+    Subcommand: Calculate density for each layer of a GDS file.
+
+    Args:
+        args (Namespace): Parsed CLI arguments.
+        pdk (PdkInformation): PDK instance with layer rules.
+
+    Returns:
+        None
+    """
+    print_density(pdk, args.input)
+
+
+def func_erase(args, pdk):
+    """
+    Subcommand: Erase all dummy fill from a GDS file.
+
+    Args:
+        args (Namespace): Parsed CLI arguments.
+        pdk (PdkInformation): PDK instance with layer rules.
+
+    Returns:
+        None
+    """
+    erase_fill(pdk, args.input)
+
+
+def is_valid_file(value: str):
+    """
+    Argparse validator: ensure argument points to an existing file.
+
+    Args:
+        value (str): Path to the file.
+
+    Returns:
+        Path: Validated Path object.
+
+    Raises:
+        argparse.ArgumentTypeError: If the path does not exist or is not a file.
+    """
+    file_ = Path(value)
+    if file_.is_file():
+        return file_
+    raise argparse.ArgumentTypeError(f"File {value} doesn't exist!")
+
+
+def arguments():
+    """
+    Define CLI arguments and subcommands.
+
+    Returns:
+        argparse.Namespace: Parsed command-line arguments.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--process", default="ihp-sg13g2")
+    subparsers = parser.add_subparsers(help='subcommand help')
+    fill = subparsers.add_parser('fill', help='Fill chip with dummy metal')
+    fill.add_argument("input", type=is_valid_file)
+    fill.add_argument('--keep-data', action=argparse.BooleanOptionalAction)
+    fill.add_argument('--dry-run', action=argparse.BooleanOptionalAction)
+    fill.add_argument('--config-file', type=is_valid_file)
+    fill.add_argument('--core-size', type=float, nargs=4, metavar=('llx', 'lly', 'urx', 'ury'),
+                      help="lower left (x, y) and upper right (x, y) points of the chip core.")
+    fill.set_defaults(func=func_fill)
+
+    erase = subparsers.add_parser('erase', help='Erase dummy metal from chip')
+    erase.add_argument("input", type=is_valid_file)
+    erase.set_defaults(func=func_erase)
+
+    density = subparsers.add_parser('density', help='Calculate density for each layer')
+    density.add_argument("input", type=is_valid_file)
+    density.set_defaults(func=func_density)
+
+    return parser.parse_args()
+
+
+def main():
+    """
+    Entry point for the gdsfill CLI.
+
+    Parses arguments, checks Klayout version compatibility,
+    and dispatches to the selected subcommand.
+
+    Returns:
+        int: Exit code (0 on success, nonzero on error).
+    """
+    args = arguments()
+    pdk = PdkInformation(args.process, args.config_file if 'config_file' in args else None)
+    klayout_version = get_version()
+    if klayout_version < pdk.get_minimum_klayout_version():
+        print(f"Please install Klayout {pdk.get_minimum_klayout_version()}")
+        return 1
+
+    args.func(args, pdk)
+    return 0
+
+
+if __name__ == '__main__':
+    main()

gdsfill-0.1.0/gdsfill/library/common.py

@@ -0,0 +1,245 @@
+"""
+Common utilities for handling PDK configuration and tile metadata.
+
+This module provides:
+- `PdkInformation`: an interface for accessing process design kit (PDK)
+  configuration, constants, and layer-specific parameters.
+- `Tile`: a dataclass representing the position of a tile in the layout.
+- Utility functions for validating input files and loading YAML
+  configuration files.
+
+The functions and classes in this module are used across the GDS fill
+workflow for tasks such as density calculation, layer export, and tile
+processing.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+import yaml
+from packaging.version import Version
+
+
+class PdkInformation:
+    """
+    Accessor for PDK configuration and constants.
+
+    Loads a process-specific configuration (`configs/`) and
+    constants (`constants.yaml`) from the PDK directory and provides
+    convenient methods to query layer settings, algorithms, density
+    requirements, and rules for dummy fill.
+
+    Attributes:
+        data (dict): Contents of the process config file.
+        constants (dict): Contents of the process `constants.yaml`.
+    """
+
+    def __init__(self, process, config_file):
+        """
+        Initialize a PDK information object.
+
+        Args:
+            process (str): Name of the process directory (e.g., "ihp-sg13g2").
+            config_file (Path or str): Optional path to a custom config file.
+                                       If None, defaults to `configs/<process>.yaml`.
+        """
+        script = Path(__file__).parent.parent.resolve()
+        self.data = open_yaml(config_file if config_file else script / f"configs/{process}.yaml")
+        self.constants = open_yaml(script / process / "constants.yaml")
+
+    def get_minimum_klayout_version(self):
+        """
+        Get the minimum required KLayout version for this PDK.
+
+        Returns:
+            Version: Required version parsed as a `packaging.version.Version`.
+        """
+        return Version(self.constants['minimum_klayout'])
+
+    def get_name(self):
+        """
+        Get the name of the PDK.
+
+        Returns:
+            str: Name of the process design kit.
+        """
+        return self.data['PDK']
+
+    def get_layers(self):
+        """
+        Get all configured layers for this PDK.
+
+        Returns:
+            Iterable[Tuple[str, dict]]: List of (layer_name, properties).
+        """
+        return self.data['layers'].items()
+
+    def get_layer(self, layer: str) -> dict:
+        """
+        Get configuration details for a specific layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            dict: Layer configuration dictionary.
+        """
+        return self.data['layers'][layer]
+
+    def get_layer_tile_width(self, layer: str) -> int:
+        """
+        Get the tile width for a given layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            int: Tile width in database units.
+        """
+        if 'tile_width' in self.get_layer(layer):
+            return int(self.get_layer(layer)['tile_width'])
+        return int(self.constants['tile_width'])
+
+    def get_layer_algorithm(self, layer: str) -> list:
+        """
+        Get the fill algorithm(s) for a given layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            List[str]: List of algorithm names.
+        """
+        algo = self.get_layer(layer)['algorithm']
+        if isinstance(algo, str):
+            return [algo]
+        return algo
+
+    def get_layer_density(self, layer: str) -> float:
+        """
+        Get the target metal density for a layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            float: Target density percentage.
+        """
+        return self.get_layer(layer)['density']
+
+    def get_layer_deviation(self, layer: str) -> float:
+        """
+        Get the allowed density deviation for a layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            float: Allowed deviation percentage.
+        """
+        return self.get_layer(layer)['deviation']
+
+    def get_layer_index(self, layer: str) -> int:
+        """
+        Get the numeric index for a given layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            int: Layer index.
+        """
+        return self.constants['layers'][layer]['index']
+
+    def get_layer_fill_datatype(self, layer: str) -> int:
+        """
+        Get the GDS datatype used for fill shapes of a layer.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            int: Fill datatype.
+        """
+        return self.constants['layers'][layer]['fill']
+
+    def get_layer_max_depth(self, layer: str) -> int:
+        """
+        Get the maximum recursion depth for fill placement.
+
+        Args:
+            layer (str): Layer name.
+
+        Returns:
+            int: Maximum recursion depth.
+        """
+        return self.constants['layers'][layer]['max_depth']
+
+    def has_fill_algorithm(self, layer: str, algorithm: str) -> bool:
+        """
+        Check if a layer supports a given fill algorithm.
+
+        Args:
+            layer (str): Layer name.
+            algorithm (str): Algorithm identifier.
+
+        Returns:
+            bool: True if supported, False otherwise.
+        """
+        return self.constants['layers'][layer].get(algorithm) is not None
+
+    def get_fill_rules(self, layer: str, algorithm: str) -> dict:
+        """
+        Get the rule set for a given layer and fill algorithm.
+
+        Args:
+            layer (str): Layer name.
+            algorithm (str): Algorithm identifier.
+
+        Returns:
+            dict: Dictionary of fill rules (e.g., min/max size, spacing).
+        """
+        return self.constants['layers'][layer][algorithm]
+
+
+@dataclass
+class Tile:
+    """
+    Representation of a tile’s position in the layout.
+
+    Attributes:
+        x (int): X-coordinate of the tile.
+        y (int): Y-coordinate of the tile.
+    """
+
+    x: int
+    y: int
+
+
+def inputfile_exists(inputfile: str):
+    """
+    Check if a given file path exists.
+
+    Args:
+        inputfile (str): Path to the file.
+
+    Returns:
+        bool: True if the file exists, False otherwise.
+    """
+    file_ = Path(inputfile)
+    return file_.exists()
+
+
+def open_yaml(yamlfile: Path):
+    """
+    Load the contents of a YAML file.
+
+    Args:
+        yamlfile (Path): Path to the YAML file.
+
+    Returns:
+        dict or bool: Parsed YAML content, or False if the file does not exist.
+    """
+    if not yamlfile.exists():
+        return False
+    content = Path(yamlfile).read_text(encoding='utf-8')
+    return yaml.safe_load(content)

gdsfill-0.1.0/gdsfill/library/fill.py

@@ -0,0 +1,68 @@
+"""
+Layer filler driver.
+
+Coordinates filler insertion by selecting the appropriate algorithm
+and applying it to a given tile and layer.
+"""
+import gdstk
+
+from gdsfill.library.filler.helper import calculate_density
+from gdsfill.library.filler.overlap import fill_overlap
+from gdsfill.library.filler.square import fill_square
+from gdsfill.library.filler.track import fill_track
+
+
+ALGOS = {
+    'Overlap': fill_overlap,
+    'Square': fill_square,
+    'Track': fill_track,
+}
+
+
+def fill_layer(pdk, inputfile, layer, tiles, tile):
+    """
+    Fill a layout layer to meet density requirements.
+
+    Reads a GDS file, checks density, and applies one or more filler
+    algorithms (square or track) as defined in the PDK.
+
+    Args:
+        pdk (object): Provides layer rules and supported algorithms.
+        inputfile (Path | str): Path to the input GDS file.
+        layer (str): Target layer name.
+        tiles (dict): Tiling information for the layout.
+        tile (object): Current tile instance.
+
+    Returns:
+        bool: True if successful, False if algorithm unsupported.
+    """
+    library = gdstk.read_gds(inputfile, unit=1e-6)
+    annotated_cell = library.top_level()[0]
+
+    metal_density = calculate_density(annotated_cell)
+    desired_density = pdk.get_layer_density(layer)
+    fill_algos = pdk.get_layer_algorithm(layer)
+
+    print(f"Filling Tile {tile.x}x{tile.y}")
+    print(f"Metal density: {metal_density} %")
+    print(f"Desired density: {desired_density} % with {pdk.get_layer_deviation(layer)} % deviation")
+    print(f"Fill algorithm: {', '.join(fill_algos)}")
+
+    for fill_algo in fill_algos:
+        if fill_algo not in ALGOS:
+            print(f"Unknown fill algorithm {fill_algo} for layer {layer}")
+            return False
+
+    for fill_algo in fill_algos:
+        if not pdk.has_fill_algorithm(layer, fill_algo):
+            print(f"Unsupported fill algorithm {fill_algo} for layer {layer}")
+            return False
+
+    fill_lib = gdstk.Library("fill")
+    if metal_density < desired_density:
+        for fill_algo in fill_algos:
+            fill_cell = ALGOS[fill_algo](pdk, layer, tiles, tile, annotated_cell)
+            fill_lib.add(fill_cell)
+
+    fill_lib.write_gds(str(inputfile).replace('modified', 'filled'))
+    return True