prefab 0.4.2__py3-none-any.whl → 0.4.5__py3-none-any.whl

prefab/__init__.py

@@ -13,21 +13,22 @@ from prefab.predictor import correct
 # I/O Utilities
 # Function to load/save device images and gds files
 from prefab.io import (
-    load_device_img,   # Load device from an image file
-    load_device_gds,   # Load device from a GDSII file
-    device_to_cell     # Convert a device layout to a gdspy cell
+    load_device_img,  # Load device from an image file
+    load_device_gds,  # Load device from a GDSII file
+    device_to_cell,  # Convert a device layout to a gdstk cell
 )
 
 # Import image processing utilities
 # Functions to modify and manipulate device images
 from prefab.processor import (
-    binarize,                      # Soft binarization of grayscale images
-    binarize_hard,                 # Hard binarization of grayscale images
-    remove_padding,                # Trims excess padding from device images
-    zero_boundary,                 # Applies zero boundary to device images
-    generate_device_contour,       # Generates contour of device images
-    calculate_prediction_uncertainty, # Computes prediction uncertainty for device images
-    mse                            # Computes mean squared error between two images
+    binarize,  # Soft binarization of grayscale images
+    binarize_hard,  # Hard binarization of grayscale images
+    ternarize,  # Ternarization of grayscale images
+    remove_padding,  # Trims excess padding from device images
+    zero_boundary,  # Applies zero boundary to device images
+    generate_device_contour,  # Generates contour of device images
+    calculate_prediction_uncertainty,  # Computes prediction uncertainty for device images
+    mse,  # Computes mean squared error between two images
 )
 
 __all__ = (
@@ -37,9 +38,10 @@ __all__ = (
     "device_to_cell",
     "binarize",
     "binarize_hard",
+    "ternarize",
     "remove_padding",
     "zero_boundary",
     "generate_device_contour",
     "calculate_prediction_uncertainty",
-    "mse"
+    "mse",
 )

prefab/io.py

@@ -3,10 +3,10 @@ This module offers tools to import, export, and preprocess device layouts in mul
 nanofabrication prediction tasks.
 """
 
-from typing import Optional, List
+from typing import Optional, List, Tuple
 import matplotlib.image as img
 import numpy as np
-import gdspy
+import gdstk
 import cv2
 from prefab.processor import binarize_hard
 
@@ -15,7 +15,7 @@ def load_device_img(path: str, img_length_nm: int = None) -> np.ndarray:
     """
     Load, process and scale device image from file for prediction.
 
-    This function reads an image file, scales it according to the provided image length in 
+    This function reads an image file, scales it according to the provided image length in
     nanometers, and performs preprocessing tasks such as binarization, preparing it for prediction.
 
     Parameters
@@ -24,7 +24,7 @@ def load_device_img(path: str, img_length_nm: int = None) -> np.ndarray:
         Path to the device image file.
 
     img_length_nm : int, optional
-        Desired length of the device image in nanometers for scaling. If not provided, 
+        Desired length of the device image in nanometers for scaling. If not provided,
         the length of the original image is used.
 
     Returns
@@ -41,14 +41,18 @@ def load_device_img(path: str, img_length_nm: int = None) -> np.ndarray:
     return device
 
 
-def load_device_gds(path: str, cell_name: str,
-                    coords: Optional[List[List[int]]] = None) -> np.ndarray:
+def load_device_gds(
+    path: str,
+    cell_name: str,
+    coords: Optional[List[List[int]]] = None,
+    layer: Tuple[int, int] = (1, 0),
+) -> np.ndarray:
     """
     Load and process a device layout from a GDSII file.
 
-    This function reads a device layout from a GDSII file, performs necessary 
+    This function reads a device layout from a GDSII file, performs necessary
     preprocessing tasks such as scaling and padding, and prepares it for prediction.
-    Only the first layer (silicon) is loaded.
+    Only the specified layer is loaded.
 
     Parameters
     ----------
@@ -59,41 +63,73 @@ def load_device_gds(path: str, cell_name: str,
         Name of the GDSII cell to be loaded.
 
     coords : List[List[int]], optional
-        A list of coordinates [[xmin, ymin], [xmax, ymax]] in nm, defining the 
+        A list of coordinates [[xmin, ymin], [xmax, ymax]] in nm, defining the
         region of the cell to be loaded. If None, the entire cell is loaded.
 
+    layer : Tuple[int, int], optional
+        A tuple specifying the layer to be loaded. Default is (1, 0).
+
     Returns
     -------
     np.ndarray
         A 2D numpy array representing the preprocessed device layout, ready for prediction.
     """
-    gds = gdspy.GdsLibrary(infile=path)
-    cell = gds.cells[cell_name]
-    polygons = cell.get_polygons(by_spec=(1, 0))
-    bounds = 1000 * cell.get_bounding_box()
-    device = np.zeros((int(bounds[1][1] - bounds[0][1]),
-                       int(bounds[1][0] - bounds[0][0])))
-
-    contours = [np.array([[[int(1000*vertex[0] - bounds[0][0]),
-                            int(1000*vertex[1] - bounds[0][1])]] for vertex in polygon],
-                            dtype=np.int32)
-                            for polygon in polygons]
-
-    for contour in contours:
-        cv2.fillPoly(img=device, pts=[contour], color=(1, 1, 1))
+    gds = gdstk.read_gds(path)
+    cell = gds[cell_name]
+    polygons = cell.get_polygons(layer=layer[0], datatype=layer[1])
+    bounds = tuple(
+        tuple(1000 * x for x in sub_tuple) for sub_tuple in cell.bounding_box()
+    )
+    device = np.zeros(
+        (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0]))
+    )
+
+    contours = [
+        np.array(
+            [
+                [
+                    [
+                        int(1000 * vertex[0] - bounds[0][0]),
+                        int(1000 * vertex[1] - bounds[0][1]),
+                    ]
+                ]
+                for vertex in polygon.points
+            ],
+            dtype=np.int32,
+        )
+        for polygon in polygons
+    ]
+
+    cv2.fillPoly(img=device, pts=contours, color=(1, 1, 1))
 
     if coords is not None:
-        device = device[int(coords[0][1] - bounds[0][1]):int(coords[1][1] - bounds[0][1]),
-                        int(coords[0][0] - bounds[0][0]):int(coords[1][0] - bounds[0][0])]
+        new_device = np.zeros(
+            (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0]))
+        )
+        new_device[
+            int(coords[0][1] - bounds[0][1]) : int(coords[1][1] - bounds[0][1]),
+            int(coords[0][0] - bounds[0][0]) : int(coords[1][0] - bounds[0][0]),
+        ] = device[
+            int(coords[0][1] - bounds[0][1]) : int(coords[1][1] - bounds[0][1]),
+            int(coords[0][0] - bounds[0][0]) : int(coords[1][0] - bounds[0][0]),
+        ]
+        device = new_device
 
     device = np.flipud(device)
     device = np.pad(device, 100)
+
     return device
 
 
-def device_to_cell(device: np.ndarray, cell_name: str, library: gdspy.GdsLibrary,
-                   resolution: float = 1.0, layer: int = 1, approximation_mode: int = 2) -> gdspy.Cell:
-    """Converts a device layout to a gdspy cell for GDSII export.
+def device_to_cell(
+    device: np.ndarray,
+    cell_name: str,
+    library: gdstk.Library,
+    resolution: float = 1.0,
+    layer: int = 1,
+    approximation_mode: int = 2,
+) -> gdstk.Cell:
+    """Converts a device layout to a gdstk cell for GDSII export.
 
     This function creates a cell that represents a device layout. The created cell
     is ready to be exported as a GDSII file.
@@ -106,14 +142,14 @@ def device_to_cell(device: np.ndarray, cell_name: str, library: gdspy.GdsLibrary
     cell_name : str
         Name for the new cell.
 
-    library : gdspy.GdsLibrary
+    library : gdstk.Library
         Library to which the cell will be added.
 
     resolution : float, optional
         The resolution of the device in pixels per nm. Default is 1.0.
 
-    layer : int, optional
-        The GDSII layer to be used for the polygons. Default is 1.
+    layer : Tuple[int, int], optional
+        A tuple specifying the layer to be exported. Default is (1, 0).
 
     approximation_mode : int, optional
         The approximation method to be used for finding contours. Possible values are 1, 2, 3, and
@@ -121,17 +157,22 @@ def device_to_cell(device: np.ndarray, cell_name: str, library: gdspy.GdsLibrary
 
     Returns
     -------
-    gdspy.Cell
+    gdstk.Cell
         The newly created cell containing the device layout.
     """
-    approximation_method_mapping = {1: cv2.CHAIN_APPROX_NONE,
-                                    2: cv2.CHAIN_APPROX_SIMPLE,
-                                    3: cv2.CHAIN_APPROX_TC89_L1,
-                                    4: cv2.CHAIN_APPROX_TC89_KCOS}
+    approximation_method_mapping = {
+        1: cv2.CHAIN_APPROX_NONE,
+        2: cv2.CHAIN_APPROX_SIMPLE,
+        3: cv2.CHAIN_APPROX_TC89_L1,
+        4: cv2.CHAIN_APPROX_TC89_KCOS,
+    }
 
     device = np.flipud(device)
-    contours, hierarchy = cv2.findContours(device.astype(np.uint8), cv2.RETR_CCOMP,
-                                           approximation_method_mapping[approximation_mode])
+    contours, hierarchy = cv2.findContours(
+        device.astype(np.uint8),
+        cv2.RETR_CCOMP,
+        approximation_method_mapping[approximation_mode],
+    )
 
     outer_polygons = []
     inner_polygons = []
@@ -146,10 +187,14 @@ def device_to_cell(device: np.ndarray, cell_name: str, library: gdspy.GdsLibrary
             else:
                 inner_polygons.append(points)
 
-    polygons = gdspy.boolean(outer_polygons, inner_polygons, 'xor', layer=layer)
-    polygons.scale(resolution, resolution)
+    polygons = gdstk.boolean(
+        outer_polygons, inner_polygons, "xor", layer=layer[0], datatype=layer[1]
+    )
+    for polygon in polygons:
+        polygon.scale(resolution, resolution)
 
     cell = library.new_cell(cell_name)
-    cell.add(polygons)
+    for polygon in polygons:
+        cell.add(polygon)
 
     return cell

prefab/predictor.py

@@ -9,12 +9,14 @@ import requests
 from cv2 import imencode, imdecode, IMREAD_GRAYSCALE
 from prefab.processor import binarize_hard
 
-def predict(device: np.ndarray, model_name: str, model_tag: str,
-            binarize: bool = False) -> np.ndarray:
+
+def predict(
+    device: np.ndarray, model_name: str, model_tags: str, binarize: bool = False
+) -> np.ndarray:
     """
     Generates a prediction for a photonic device using a specified cloud-based ML model.
 
-    The function sends an image of the device to a cloud function, which uses the specified 
+    The function sends an image of the device to a cloud function, which uses the specified
     machine learning model to generate a prediction.
 
     Parameters
@@ -23,12 +25,12 @@ def predict(device: np.ndarray, model_name: str, model_tag: str,
         A binary numpy matrix representing the shape of a device.
 
     model_name : str
-        The name of the ML model to use for the prediction. 
+        The name of the ML model to use for the prediction.
         Consult the module's documentation for available models.
 
-    model_num : str
-        The version number of the ML model. 
-        Consult the module's documentation for available versions.
+    model_tags : Union[str, List[str]]
+        The tags of the ML model.
+        Consult the module's documentation for available tags.
 
     binarize : bool, optional
         If set to True, the prediction will be binarized (default is False).
@@ -36,30 +38,36 @@ def predict(device: np.ndarray, model_name: str, model_tag: str,
     Returns
     -------
     np.ndarray
-        A numpy matrix representing the predicted shape of the device. Pixel values closer 
-        to 1 indicate a higher likelihood of core material, while pixel values closer to 0 
-        suggest a higher likelihood of cladding material. Pixel values in between represent 
+        A numpy matrix representing the predicted shape of the device. Pixel values closer
+        to 1 indicate a higher likelihood of core material, while pixel values closer to 0
+        suggest a higher likelihood of cladding material. Pixel values in between represent
         prediction uncertainty.
     """
-    function_url = 'https://prefab-photonics--predict.modal.run'
+    function_url = "https://prefab-photonics--predict.modal.run"
 
-    predict_data = {'device': _encode_image(device),
-                    'model_name': model_name,
-                    'model_tag': model_tag}
+    predict_data = {
+        "device": _encode_image(device),
+        "model_name": model_name,
+        "model_tags": model_tags,
+    }
 
-    prediction = _decode_image(requests.post(function_url, json=predict_data, timeout=200))
+    prediction = _decode_image(
+        requests.post(function_url, json=predict_data, timeout=200)
+    )
 
     if binarize:
         prediction = binarize_hard(prediction)
 
     return prediction
 
-def correct(device: np.ndarray, model_name: str, model_tag: str,
-            binarize: bool = False) -> np.ndarray:
+
+def correct(
+    device: np.ndarray, model_name: str, model_tags: str, binarize: bool = False
+) -> np.ndarray:
     """
     Generates a correction for a photonic device using a specified cloud-based ML model.
 
-    The function sends an image of the device to a cloud function, which uses the specified 
+    The function sends an image of the device to a cloud function, which uses the specified
     machine learning model to generate a correction.
 
     Parameters
@@ -68,12 +76,12 @@ def correct(device: np.ndarray, model_name: str, model_tag: str,
         A binary numpy matrix representing the shape of a device.
 
     model_name : str
-        The name of the ML model to use for the correction. 
+        The name of the ML model to use for the correction.
         Consult the module's documentation for available models.
 
-    model_num : str
-        The version number of the ML model. 
-        Consult the module's documentation for available versions.
+    model_tags : Union[str, List[str]]
+        The tags of the ML model.
+        Consult the module's documentation for available tags.
 
     binarize : bool, optional
         If set to True, the correction will be binarized (default is False).
@@ -81,24 +89,29 @@ def correct(device: np.ndarray, model_name: str, model_tag: str,
     Returns
     -------
     np.ndarray
-        A numpy matrix representing the corrected shape of the device. Pixel values closer 
-        to 1 indicate a higher likelihood of core material, while pixel values closer to 0 
-        suggest a higher likelihood of cladding material. Pixel values in between represent 
+        A numpy matrix representing the corrected shape of the device. Pixel values closer
+        to 1 indicate a higher likelihood of core material, while pixel values closer to 0
+        suggest a higher likelihood of cladding material. Pixel values in between represent
         correction uncertainty.
     """
-    function_url = 'https://prefab-photonics--correct.modal.run'
+    function_url = "https://prefab-photonics--correct.modal.run"
 
-    correct_data = {'device': _encode_image(device),
-                    'model_name': model_name,
-                    'model_tag': model_tag}
+    correct_data = {
+        "device": _encode_image(device),
+        "model_name": model_name,
+        "model_tags": model_tags,
+    }
 
-    correction = _decode_image(requests.post(function_url, json=correct_data, timeout=200))
+    correction = _decode_image(
+        requests.post(function_url, json=correct_data, timeout=200)
+    )
 
     if binarize:
         correction = binarize_hard(correction)
 
     return correction
 
+
 def _encode_image(image: np.ndarray) -> str:
     """
     Encodes a numpy image array to its base64 representation.
@@ -113,10 +126,11 @@ def _encode_image(image: np.ndarray) -> str:
     str
         The base64 encoded string of the image.
     """
-    encoded_image = imencode('.png', 255 * image)[1].tobytes()
-    encoded_image_base64 = base64.b64encode(encoded_image).decode('utf-8')
+    encoded_image = imencode(".png", 255 * image)[1].tobytes()
+    encoded_image_base64 = base64.b64encode(encoded_image).decode("utf-8")
     return encoded_image_base64
 
+
 def _decode_image(encoded_image_base64: str) -> np.ndarray:
     """
     Decodes a base64 encoded image to its numpy array representation.

prefab/processor.py

@@ -13,10 +13,10 @@ def binarize(device: np.ndarray, eta: float = 0.5, beta: float = np.inf) -> np.n
     """
     Applies soft binarization to a device image using a sigmoid function.
 
-    The binarization process can be controlled by adjusting the thresholding level (`eta`) 
-    and the steepness of the sigmoid function (`beta`). `eta` influences the threshold level 
-    for binarization, simulating under-etching for smaller values and over-etching for larger 
-    values. `beta` controls the steepness of the sigmoid function, thereby determining the 
+    The binarization process can be controlled by adjusting the thresholding level (`eta`)
+    and the steepness of the sigmoid function (`beta`). `eta` influences the threshold level
+    for binarization, simulating under-etching for smaller values and over-etching for larger
+    values. `beta` controls the steepness of the sigmoid function, thereby determining the
     degree of binarization.
 
     Parameters
@@ -28,7 +28,7 @@ def binarize(device: np.ndarray, eta: float = 0.5, beta: float = np.inf) -> np.n
         Threshold level for binarization, with values between 0 and 1. Default is 0.5.
 
     beta : float, optional
-        Controls the steepness of the sigmoid function and thereby the degree of 
+        Controls the steepness of the sigmoid function and thereby the degree of
         binarization. Default is infinity, resulting in maximum binarization.
 
     Returns
@@ -36,8 +36,8 @@ def binarize(device: np.ndarray, eta: float = 0.5, beta: float = np.inf) -> np.n
     np.ndarray
         A 2D numpy array representing the binarized device image.
     """
-    numerator = np.tanh(beta*eta) + np.tanh(beta*(device - eta))
-    denominator = np.tanh(beta*eta) + np.tanh(beta*(1 - eta))
+    numerator = np.tanh(beta * eta) + np.tanh(beta * (device - eta))
+    denominator = np.tanh(beta * eta) + np.tanh(beta * (1 - eta))
     device_bin = numerator / denominator
     return device_bin
 
@@ -48,9 +48,9 @@ def binarize_hard(device: np.ndarray, eta: float = 0.5) -> np.ndarray:
 
     The binarization process depends solely on the threshold level (`eta`), which
     controls the demarcation point for determining the binary values in the output image.
-    Smaller `eta` values simulate under-etching (more pixels are turned off), while 
+    Smaller `eta` values simulate under-etching (more pixels are turned off), while
     larger `eta` values simulate over-etching (more pixels are turned on). Compared to the
-    sigmoid binarization function, this hard binarization method is less likely to produce 
+    sigmoid binarization function, this hard binarization method is less likely to produce
     NaN values and may sometimes yield better results.
 
     Parameters
@@ -72,12 +72,46 @@ def binarize_hard(device: np.ndarray, eta: float = 0.5) -> np.ndarray:
     return device_bin
 
 
+def ternarize(device: np.ndarray, eta1: float = 0.33, eta2: float = 0.66) -> np.ndarray:
+    """
+    Applies ternarization to a device image using two thresholds.
+
+    This function performs a ternarization process on a given device image, dividing it into three
+    distinct regions based on two threshold values (`eta1` and `eta2`). It assigns three different
+    values (0, 1, or 2) to each pixel based on its intensity in relation to the thresholds.
+    Pixels with intensity less than `eta1` are assigned 0, pixels with intensity greater than or
+    equal to `eta2` are assigned 2, and pixels with intensity between `eta1` and `eta2` are
+    assigned 1. This function can be useful for categorizing different regions in a device image.
+
+    Parameters
+    ----------
+    device : np.ndarray
+        A 2D numpy array representing the grayscale device image to be ternarized.
+
+    eta1 : float, optional
+        First threshold level for ternarization, with values between 0 and 1. Default is 0.33.
+
+    eta2 : float, optional
+        Second threshold level for ternarization, with values between 0 and 1. Default is 0.66.
+
+    Returns
+    -------
+    np.ndarray
+        A 2D numpy array representing the ternarized device image.
+    """
+    device_ter = np.copy(device)
+    device_ter[device_ter < eta1] = 0
+    device_ter[device_ter >= eta2] = 1
+    device_ter[(device_ter >= eta1) & (device_ter < eta2)] = 0.5
+    return device_ter
+
+
 def remove_padding(device: np.ndarray) -> np.ndarray:
     """
     Removes the empty padding from the edges of a device.
 
-    This function eliminates rows and columns from the edges of the device matrix 
-    that are entirely zeros, effectively removing any unnecessary padding present 
+    This function eliminates rows and columns from the edges of the device matrix
+    that are entirely zeros, effectively removing any unnecessary padding present
     in the device representation.
 
     Parameters
@@ -92,8 +126,10 @@ def remove_padding(device: np.ndarray) -> np.ndarray:
         of equal or smaller size compared to the input device.
     """
     nonzero_rows, nonzero_cols = np.nonzero(device)
-    trimmed_device = device[nonzero_rows.min():nonzero_rows.max()+1, 
-                            nonzero_cols.min():nonzero_cols.max()+1]
+    trimmed_device = device[
+        nonzero_rows.min() : nonzero_rows.max() + 1,
+        nonzero_cols.min() : nonzero_cols.max() + 1,
+    ]
     return trimmed_device
 
 
@@ -101,8 +137,8 @@ def zero_boundary(device: np.ndarray, margin: int) -> np.ndarray:
     """
     Sets the boundaries of a device matrix to zero up to a specified margin.
 
-    This function zeroes the outermost rows and columns of the device matrix 
-    up to a distance (margin) from the boundaries, effectively creating a 
+    This function zeroes the outermost rows and columns of the device matrix
+    up to a distance (margin) from the boundaries, effectively creating a
     "zeroed" frame around the device representation.
 
     Parameters
@@ -116,7 +152,7 @@ def zero_boundary(device: np.ndarray, margin: int) -> np.ndarray:
     Returns
     -------
     np.ndarray
-        A 2D numpy array representing the shape of the device with its outermost 
+        A 2D numpy array representing the shape of the device with its outermost
         rows and columns up to 'margin' distance set to zero.
     """
     zeroed_device = device.copy()
@@ -127,12 +163,14 @@ def zero_boundary(device: np.ndarray, margin: int) -> np.ndarray:
     return zeroed_device
 
 
-def generate_device_contour(device: np.ndarray, linewidth: Optional[int] = None) -> np.ndarray:
+def generate_device_contour(
+    device: np.ndarray, linewidth: Optional[int] = None
+) -> np.ndarray:
     """
     Generates a contour of a device for visualization purposes.
 
-    This function generates a binary contour of a device's shape which can be overlaid 
-    on top of the device's image for better visualization. The thickness of the contour 
+    This function generates a binary contour of a device's shape which can be overlaid
+    on top of the device's image for better visualization. The thickness of the contour
     line can be specified, with a default value calculated as 1% of the device's height.
 
     Parameters
@@ -141,7 +179,7 @@ def generate_device_contour(device: np.ndarray, linewidth: Optional[int] = None)
         A 2D numpy array representing the device's shape.
 
     linewidth : int, optional
-        The width of the contour line. If not provided, the linewidth is set 
+        The width of the contour line. If not provided, the linewidth is set
         to 1% of the device's height.
 
     Returns
@@ -153,8 +191,9 @@ def generate_device_contour(device: np.ndarray, linewidth: Optional[int] = None)
         linewidth = device.shape[0] // 100
 
     binary_device = binarize_hard(device).astype(np.uint8)
-    contours, _ = cv2.findContours(binary_device, mode=cv2.RETR_CCOMP,
-                                   method=cv2.CHAIN_APPROX_SIMPLE)
+    contours, _ = cv2.findContours(
+        binary_device, mode=cv2.RETR_CCOMP, method=cv2.CHAIN_APPROX_SIMPLE
+    )
 
     contour_overlay = np.zeros_like(device)
     cv2.drawContours(contour_overlay, contours, -1, (255, 255, 255), linewidth)
@@ -166,11 +205,11 @@ def calculate_prediction_uncertainty(prediction: np.ndarray) -> np.ndarray:
     """
     Computes the uncertainty profile of a non-binary prediction matrix.
 
-    This function quantifies the level of uncertainty in a given prediction matrix by 
-    identifying the areas between the core (value 1) and cladding (value 0). These regions 
-    often correspond to the boundaries of the predicted structure and are represented by 
-    pixel values ranging between 0 and 1 in the prediction matrix. The function calculates 
-    the uncertainty as the distance from the pixel value to the nearest extreme (0 or 1), 
+    This function quantifies the level of uncertainty in a given prediction matrix by
+    identifying the areas between the core (value 1) and cladding (value 0). These regions
+    often correspond to the boundaries of the predicted structure and are represented by
+    pixel values ranging between 0 and 1 in the prediction matrix. The function calculates
+    the uncertainty as the distance from the pixel value to the nearest extreme (0 or 1),
     highlighting regions of maximum uncertainty.
 
     Parameters
@@ -181,13 +220,14 @@ def calculate_prediction_uncertainty(prediction: np.ndarray) -> np.ndarray:
     Returns
     -------
     np.ndarray
-        A 2D numpy array (same shape as the input prediction matrix) representing the 
-        uncertainty profile of the prediction. Higher values correspond to areas of higher 
+        A 2D numpy array (same shape as the input prediction matrix) representing the
+        uncertainty profile of the prediction. Higher values correspond to areas of higher
         uncertainty.
     """
     uncertainty = 1 - 2 * np.abs(0.5 - prediction)
     return uncertainty
 
+
 def mse(prediction: np.ndarray, device: np.ndarray) -> float:
     """
     Computes the mean squared error (MSE) between a prediction and a device matrix.
@@ -205,4 +245,4 @@ def mse(prediction: np.ndarray, device: np.ndarray) -> float:
     float
         The mean squared error between the prediction and device matrices.
     """
-    return np.mean((prediction - device)**2)
+    return np.mean((prediction - device) ** 2)

{prefab-0.4.2.dist-info → prefab-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefab
-Version: 0.4.2
+Version: 0.4.5
 Summary: Machine learning based prediction of photonic device fabrication
 Project-URL: Homepage, https://github.com/PreFab-Photonics/PreFab
 Author-email: Dusan Gostimirovic <dusan@prefabphotonics.com>
@@ -525,7 +525,7 @@ Description-Content-Type: text/markdown
 
 ![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/assets/logo.png?raw=true)
 
-`PreFab` leverages **deep learning** to model fabrication-induced structural variations in integrated photonic devices. Through this *virtual nanofabrication environment*, we uncover valuable insights into nanofabrication processes and enhance device design accuracy.
+`PreFab` leverages **deep learning** to model fabrication-induced structural variations in integrated photonic devices. Through this _virtual nanofabrication environment_, we uncover valuable insights into nanofabrication processes and enhance device design accuracy.
 
 ## Prediction
 
@@ -541,16 +541,16 @@ Description-Content-Type: text/markdown
 
 ## Models
 
-`PreFab` accommodates unique *predictor* and *corrector* models for each photonic foundry, regularly updated based on recent fabrication data. Current models include (see full list on [`docs/models.md`](docs/models.md)):
+`PreFab` accommodates unique _predictor_ and _corrector_ models for each photonic foundry, regularly updated based on recent fabrication data. Current models include (see full list on [`docs/models.md`](docs/models.md)):
 
-| Foundry | Process | Latest Version | Latest Dataset | Model Name | Model Tag | Status |
-| ------- | ------- | -------------- | -------------- | ---------- |---------- | ------ |
-| ANT | [NanoSOI](https://www.appliednt.com/nanosoi-fabrication-service/) | v5 (Jun 3 2023) | d4 (Apr 12 2023) | ANT_NanoSOI | v5-d4 | Beta |
-| ANT | [SiN (Upper Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023) | d0 (Jun 1 2023) | ANT_SiN | v5-d0-upper | Alpha |
-| ANT | [SiN (Lower Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023) | d0 (Jun 1 2023) | ANT_SiN | v5-d0-lower | Alpha |
-| SiEPICfab | [SOI](https://siepic.ca/fabrication/) | v5 (Jun 3 2023) | d0 (Jun 14 2023) | SiEPICfab_SOI | v5-d0 | Alpha |
+| Foundry   | Process                                                                            | Latest Version  | Latest Dataset   | Model Name    | Model Tag   | Status |
+| --------- | ---------------------------------------------------------------------------------- | --------------- | ---------------- | ------------- | ----------- | ------ |
+| ANT       | [NanoSOI](https://www.appliednt.com/nanosoi-fabrication-service/)                  | v5 (Jun 3 2023) | d4 (Apr 12 2023) | ANT_NanoSOI   | v5-d4       | Beta   |
+| ANT       | [SiN (Upper Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023) | d0 (Jun 1 2023)  | ANT_SiN       | v5-d0-upper | Alpha  |
+| ANT       | [SiN (Lower Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023) | d0 (Jun 1 2023)  | ANT_SiN       | v5-d0-lower | Alpha  |
+| SiEPICfab | [SOI](https://siepic.ca/fabrication/)                                              | v5 (Jun 3 2023) | d0 (Jun 14 2023) | SiEPICfab_SOI | v5-d0       | Alpha  |
 
-*New models and foundries are regularly added. Usage may change. For additional foundry and process models, feel free to contact us or raise an issue.*
+_New models and foundries are regularly added. Usage may change. For additional foundry and process models, feel free to contact us or raise an issue._
 
 ## Installation
 

prefab-0.4.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+prefab/__init__.py,sha256=0r0FhWL0XnAE_rq9OuqrNsXNOWjU8eI3-wMvHVDBHWc,1461
+prefab/io.py,sha256=lSjtxbk3YmWhG816Ok-LgjMceZIU1lRZy7pWaPlCpF4,6007
+prefab/predictor.py,sha256=BvcmoUuN3g_MNb9IichHMmueqQILnQK7U8LureMXJec,4562
+prefab/processor.py,sha256=lmSOTouyFOb8UZo7JLXi78VjdUz6eJoOyPZMn6IKraw,8996
+prefab-0.4.5.dist-info/METADATA,sha256=GNbIUFC4ZQZZO0KEHxnVxnn6SxXMbczdrdhnjUZpXHw,35014
+prefab-0.4.5.dist-info/WHEEL,sha256=mRYSEL3Ih6g5a_CVMIcwiF__0Ae4_gLYh01YFNwiq1k,87
+prefab-0.4.5.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-0.4.5.dist-info/RECORD,,

{prefab-0.4.2.dist-info → prefab-0.4.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.18.0
+Generator: hatchling 1.21.0
 Root-Is-Purelib: true
 Tag: py3-none-any

prefab-0.4.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-prefab/__init__.py,sha256=6PDbpXSExwKQHTl9AxJeSrB8EOPYcHCgq_7zsFcmGBY,1488
-prefab/io.py,sha256=1pkSb8OEz2woqYo81mJ-EgRqsLfh21YtvIi5OuSlZVk,5326
-prefab/predictor.py,sha256=fc7LRJgTc8SIm-bpNEoDspgth2Fd0k6UTdkAdgbmwBQ,4556
-prefab/processor.py,sha256=DH8IX7fx_TMbnvfjfR-acy-JAnYz1efxdQHgLFgF9_k,7580
-prefab-0.4.2.dist-info/METADATA,sha256=y3P_3VSWthzRd3vmD0bu-Wslz3_1JKQIVm6jvJhuaiU,34731
-prefab-0.4.2.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
-prefab-0.4.2.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-0.4.2.dist-info/RECORD,,