prefab 1.1.1__tar.gz → 1.1.3__tar.gz

{prefab-1.1.1 → prefab-1.1.3}/.github/workflows/docs-deploy.yml

@@ -18,17 +18,18 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: 3.x
-      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
+      - id: get_cache_id
+        run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_OUTPUT
       - uses: actions/cache@v4
         with:
-          key: mkdocs-material-${{ env.cache_id }}
+          key: mkdocs-material-${{ steps.get_cache_id.outputs.cache_id }}
           path: .cache
           restore-keys: |
             mkdocs-material-
       - run: pip install mkdocs
       - run: pip install mkdocs-material
       - run: pip install mkdocstrings[python]
-      - run: pip install mknotebooks
+      - run: pip install mkdocs-jupyter
       - name: Create CNAME file
         run: echo "docs.prefabphotonics.com" > docs/CNAME
       - run: mkdocs gh-deploy --force

{prefab-1.1.1 → prefab-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prefab
-Version: 1.1.1
+Version: 1.1.3
 Summary: Artificial nanofabrication of integrated photonic circuits using deep learning
 Project-URL: Homepage, https://prefabphotonics.com
 Project-URL: Repository, https://github.com/PreFab-Photonics/PreFab
@@ -516,7 +516,7 @@ Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGP
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: gdstk
+Requires-Dist: gdstk>=0.9.55
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: opencv-python-headless
@@ -533,23 +533,23 @@ Description-Content-Type: text/markdown
 
 ![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/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 is a _virtual nanofabrication environment_ that leverages **deep learning** and **computer vision** to predict and correct for structural variations in integrated photonic devices during nanofabrication.
 
 ## Prediction
 
-PreFab accurately predicts process-induced structural alterations such as corner rounding, washing away of small lines and islands, and filling of narrow holes in planar photonic devices. This enables designers to quickly prototype expected performance and rectify designs prior to nanofabrication.
+PreFab predicts process-induced structural variations, including corner rounding, loss of small lines and islands, filling of narrow holes and channels, sidewall angle deviations, and stochastic effects. This allows designers to rapidly prototype and evaluate expected performance pre-fabrication.
 
 ![Example of PreFab prediction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_p.png?raw=true)
 
 ## Correction
 
-PreFab automates corrections to device designs, ensuring the fabricated outcome aligns with the original design. This results in reduced structural variation and performance disparity from simulation to experiment.
+PreFab corrects device designs to ensure that the fabricated outcome closely matches the intended specifications. This minimizes structural variations and reduces performance discrepancies between simulations and actual experiments.
 
 ![Example of PreFab correction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_c.png?raw=true)
 
 ## 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`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
+Each photonic nanofabrication process requires unique models, which are regularly updated with the latest data. The current models include (see the full list in [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
 
 | Foundry | Process | Latest Version    | Latest Dataset   | Model Name  |
 | ------- | ------- | ----------------- | ---------------- | ----------- |
@@ -557,7 +557,7 @@ PreFab accommodates unique _predictor_ and _corrector_ models for each photonic
 | ANT     | SiN     | ANF1 (May 6 2024) | d1 (Jan 31 2024) | ANT_SiN_ANF1_d1 |
 | Generic | DUV-SOI | ANF1 (May 6 2024) | d0 (Jul 30 2024) | generic_DUV_SOI_ANF1_d0 |
 
-> _New models and foundries are to be regularly added. Usage may change. For additional foundry and process models, feel free to contact us._
+> _New models are to be regularly added. Usage may change. For additional foundry and process models, feel free to [contact us](mailto:hi@prefabphotonics.com) or raise an issue._
 
 ## Installation
 
@@ -581,7 +581,7 @@ pip install -e .
 
 Before you can make PreFab requests, you will need to [create an account](https://www.prefabphotonics.com/login).
 
-To link your account, you will need a token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
+To link your account, you will need an token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
 
 ```sh
 python3 -m prefab setup
@@ -593,11 +593,11 @@ Visit [`/docs/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/do
 
 ## Performance and Usage
 
-PreFab models are served via a serverless cloud platform. Please note:
+PreFab models are hosted on a [serverless cloud platform](https://modal.com/). Please keep in mind:
 
-- 🐢 CPU inference may result in slower performance. Future updates will introduce GPU inference.
-- 🥶 The first prediction may take longer due to cold start server loading. Subsequent predictions will be faster.
-- 😊 Be considerate of usage. Start small and limit usage during the initial stages. Thank you!
+- 🐢 Default CPU inference may be slower.
+- 🥶 The first prediction using optional GPU inference may take longer due to cold start server loading. Subsequent predictions will be faster.
+- 😊 Please be considerate of usage. Start with small tasks and limit usage during the initial stages. Thank you!
 
 ## License
 

prefab-1.1.3/README.md

@@ -0,0 +1,73 @@
+# PreFab
+
+![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/logo.png?raw=true)
+
+PreFab is a _virtual nanofabrication environment_ that leverages **deep learning** and **computer vision** to predict and correct for structural variations in integrated photonic devices during nanofabrication.
+
+## Prediction
+
+PreFab predicts process-induced structural variations, including corner rounding, loss of small lines and islands, filling of narrow holes and channels, sidewall angle deviations, and stochastic effects. This allows designers to rapidly prototype and evaluate expected performance pre-fabrication.
+
+![Example of PreFab prediction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_p.png?raw=true)
+
+## Correction
+
+PreFab corrects device designs to ensure that the fabricated outcome closely matches the intended specifications. This minimizes structural variations and reduces performance discrepancies between simulations and actual experiments.
+
+![Example of PreFab correction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_c.png?raw=true)
+
+## Models
+
+Each photonic nanofabrication process requires unique models, which are regularly updated with the latest data. The current models include (see the full list in [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
+
+| Foundry | Process | Latest Version    | Latest Dataset   | Model Name  |
+| ------- | ------- | ----------------- | ---------------- | ----------- |
+| ANT     | NanoSOI | ANF1 (May 6 2024) | d10 (Jun 8 2024) | ANT_NanoSOI_ANF1_d10 |
+| ANT     | SiN     | ANF1 (May 6 2024) | d1 (Jan 31 2024) | ANT_SiN_ANF1_d1 |
+| Generic | DUV-SOI | ANF1 (May 6 2024) | d0 (Jul 30 2024) | generic_DUV_SOI_ANF1_d0 |
+
+> _New models are to be regularly added. Usage may change. For additional foundry and process models, feel free to [contact us](mailto:hi@prefabphotonics.com) or raise an issue._
+
+## Installation
+
+Install PreFab via pip:
+
+```sh
+pip install prefab
+```
+
+Or clone the repository and install in development mode:
+
+```sh
+git clone https://github.com/PreFab-Photonics/PreFab.git
+cd PreFab
+pip install -e .
+```
+
+## Getting Started
+
+### Account setup
+
+Before you can make PreFab requests, you will need to [create an account](https://www.prefabphotonics.com/login).
+
+To link your account, you will need an token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
+
+```sh
+python3 -m prefab setup
+```
+
+### Guides
+
+Visit [`/docs/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/docs/examples) or our [docs](https://docs.prefabphotonics.com/) to get started with your first predictions.
+
+## Performance and Usage
+
+PreFab models are hosted on a [serverless cloud platform](https://modal.com/). Please keep in mind:
+
+- 🐢 Default CPU inference may be slower.
+- 🥶 The first prediction using optional GPU inference may take longer due to cold start server loading. Subsequent predictions will be faster.
+- 😊 Please be considerate of usage. Start with small tasks and limit usage during the initial stages. Thank you!
+
+## License
+
+This project is licensed under the LGPL-2.1 license. © 2024 PreFab Photonics.

{prefab-1.1.1 → prefab-1.1.3/docs}/CHANGELOG.md

@@ -1,44 +1,43 @@
 # Changelog
 
-## 1.1.1 - 2024-09-24
+## [1.1.3](https://github.com/PreFab-Photonics/PreFab/releases/tag/v1.1.3) - 2024-10-26
 
-### Changed
+- Moved prediction logic to `prefab.predict` module.
+- First version of `predict.predict_array_with_grad`, which returns both the predicted array and its gradient. This is useful to fabrication-aware inverse design (FAID). More to come.
+- Added `origin` parameter to GDS-related export methods.
+- Small docstring fixes.
 
-- Manually adding small random noise to the semulated images to better match the real data. This is ideally included in the model training, but for now this is a quick fix.
-- Added z-padding to the device array before exporting to STL with `Device.to_stl` to ensure that the exported device is closed.
+## [1.1.2](https://github.com/PreFab-Photonics/PreFab/releases/tag/v1.1.2) - 2024-10-10
 
-### Fixed
+- User warning if `compare.intersection_over_union`, `compare.hamming_distance`, or `compare.dice_coefficient` are called with non-binarized devices.
+- Added `height` parameter to many shape constructors in `prefab.shapes` to give more flexibility.
+- Updates to the `README.md` to keep current.
+- `Device.is_binary` is now a property.
+- Moved `Device.enforce_feature_size` logic to `prefab.geometry` module.
+- Added required version of `gdstk` to `pyproject.toml`.
+- Removed leftover return statement in `geometry.rotate`.
 
-- Removed buffer from `Device.device_array` before exporting to with `Device.to_gdsfactory`.
-
-### Added
+## [1.1.1](https://github.com/PreFab-Photonics/PreFab/releases/tag/v1.1.1) - 2024-09-24
 
+- Manually adding small random noise to the semulated images to better match the real data. This is ideally included in the model training, but for now this is a quick fix.
+- Added z-padding to the device array before exporting to STL with `Device.to_stl` to ensure that the exported device is closed.
+- Removed buffer from `Device.device_array` before exporting to with `Device.to_gdsfactory`.
 - The additions from `1.0.3` and `1.0.4` releases, which should be considered part of this release. Release planning a work in progress.
 - Import and export from/to Tidy3D simulations with `Device.to_tidy3d` and `read.from_tidy3d`.
 - Import and export from/to gdsfactory components with `Device.to_gdsfactory` and `read.from_gdsfactory`.
 - Convert 2D device structures into 3D arrays or STL files with `Device.to_3d` and `Device.to_stl`. This is useful for simulating processes with angled sidewalls.
 - Check and visualize the effect of enforcing a minimum feature size on the device geometry with `Device.check_feature_size` and `Device.enforce_feature_size`.
 
-## 1.0.4 - 2024-09-19
-
-### Added
+## [1.0.4](https://github.com/PreFab-Photonics/PreFab/releases/tag/v1.0.4) - 2024-09-19
 
 - Option to specify GPU or CPU in `predict`, `correct`, and `semulate` functions. GPU option has more overhead and will take longer for small devices, but will be faster for larger devices.
-
-### Changed
-
 - Improve clarity of messaging for authentication errors.
 
-## 1.0.3 - 2024-09-14
-
-### Added
+## [1.0.3](https://github.com/PreFab-Photonics/PreFab/releases/tag/v1.0.3) - 2024-09-14
 
 - Added this `CHANGELOG.md` file.
 - Added `prefab.shapes` module to replace the now removed `devices` directory. This module contains helpful device constructors for testing PreFab models on.
 - Added `__version__` class attribute to `prefab` package.
-
-### Changed
-
 - Added `ANT_NanoSOI_ANF1-d8` and `ANT_NanoSOI_ANF1-d10` models (see `prefab.models` and `docs/models.md`).
 - Updated notebook examples to use `prefab.shapes` module and newest models.
 - Updated dependencies in `pyproject.toml`.
@@ -46,13 +45,7 @@
 - Docstring improvements to `prefab.compare` module.
 - Ability to specify thickness to all four sides of buffer thickness in `prefab.device.BufferSpec`.
 - Changed some of the array resizing logic in `prefab.read` module to be more robust.
-
-### Fixed
-
 - Minor fixes to `prefab.device` module.
 - Minor fixes to `prefab.geometry` module.
-
-### Removed
-
 - Removed `devices` directory from the repository. Effectively replaced with `prefab.shapes` module.
 - Remove `requirements.txt` file as `pyproject.toml` contains all dependencies.

prefab-1.1.3/docs/blog/.authors.yml

@@ -0,0 +1,6 @@
+authors:
+  dusan:
+    name: Dusan Gostimirovic
+    description: Founder
+    avatar: https://media.licdn.com/dms/image/v2/C4E03AQGWxb8cTGgvjg/profile-displayphoto-shrink_400_400/profile-displayphoto-shrink_400_400/0/1516680366321?e=1734566400&v=beta&t=h0PjBVxodvAKFt-MpKUNZOkXG6t-Tvn4HAdHwNoAWQY
+    url: https://www.linkedin.com/in/dusangostimirovic/

prefab-1.1.3/docs/blog/index.md

@@ -0,0 +1,2 @@
+# Blog
+

prefab-1.1.3/docs/blog/posts/prefab-v1.1.0.md

@@ -0,0 +1,273 @@
+---
+date: 2024-09-23
+authors: [dusan]
+---
+
+# PreFab v1.1.0
+
+[PreFab v1.1.0](https://github.com/PreFab-Photonics/PreFab) is now available! Install it via [PyPI](https://pypi.org/project/prefab/) with the following command:
+
+```bash
+pip install --upgrade prefab
+```
+
+**PreFab is a Python library designed to predict and correct nanofabrication variations in integrated photonic devices using advanced computer vision models.** It helps enhance fabrication awareness and boosts efficiency in the design, fabrication, and testing of photonic circuits.
+
+<!-- more -->
+
+## What's new with us
+
+PreFab is a new startup originating from [McGill University](https://www.mcgill.ca/) in Montreal, Canada. As we continue to grow, we are eager to learn about your needs and how we can enhance our platform. Our team is small, so we appreciate your patience as we work on these improvements. Reach out to us at [hi@prefabphotonics.com](mailto:hi@prefabphotonics.com) to work together.
+
+- **We have launched a new LinkedIn page** [here](https://www.linkedin.com/company/prefab-photonics/) where we will announce new features and updates. Follow us to stay informed.
+
+- **We've updated our logo** to be less busy while retaining its original charm and essence. We hope you like the new design!
+
+![New PreFab Logo](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/logo.png?raw=true)
+
+## Features
+
+This release brings a host of new features and enhancements to elevate your experience with PreFab. While our core functionality of predicting and correcting nanofabrication variations remains unchanged, we've added several valuable tools for working with nanostructure geometries.
+
+### Shapes
+
+While `read.from_gds` is used to import your GDS cells, the new `shapes` module allows you to create basic nanostructure devices directly. This feature is not only beneficial for our internal testing but also provides a convenient way for you to test PreFab models on simple geometries. Below are some examples.
+
+```python
+import prefab as pf
+
+target = pf.shapes.target(width=500, arm_width=60)
+target.plot()
+
+grating = pf.shapes.grating(height=500, pitch=120, duty_cycle=0.5, num_gratings=10)
+grating.plot()
+
+radial_grating = pf.shapes.radial_grating(width=500, num_gratings=10)
+radial_grating.plot()
+```
+
+    <Axes: xlabel='x (nm)', ylabel='y (nm)'>
+
+
+
+
+    
+![png](prefab-v1.1.0_files/prefab-v1.1.0_3_1.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_3_2.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_3_3.png)
+
+### GPU acceleration
+
+We've introduced GPU acceleration to the backend of PreFab by specifying `gpu=True` in `Device.predict` and `Device.correct`. This enhancement should speed up predictions for larger devices. As PreFab is a free service, CPU inference remains the default to keep the service readily available ("hot") for users. For now, the GPU will be in a "cold" state, requiring additional time to start up. Consequently, the first GPU prediction will be slower due to this overhead. We kindly ask that you use the GPU feature modestly (scouts' honor).
+
+```python
+import time
+
+import prefab as pf
+
+grating = pf.shapes.grating(height=500, pitch=120, duty_cycle=0.5, num_gratings=200)
+
+# Timing the CPU correction
+start_time = time.time()
+grating_c_cpu = grating.correct(model=pf.models["ANT_NanoSOI_ANF1_d10"], gpu=False)
+cpu_duration = time.time() - start_time
+print(f"CPU correction time: {cpu_duration:.2f} seconds")
+
+# Timing the first GPU correction (cold start)
+start_time = time.time()
+grating_c_gpu = grating.correct(model=pf.models["ANT_NanoSOI_ANF1_d10"], gpu=True)
+gpu_duration = time.time() - start_time
+print(f"Cold GPU correction time: {gpu_duration:.2f} seconds")
+
+# Timing the second GPU correction (hot start)
+start_time = time.time()
+grating_c_gpu2 = grating.correct(model=pf.models["ANT_NanoSOI_ANF1_d10"], gpu=True)
+gpu_duration2 = time.time() - start_time
+print(f"Hot GPU correction time: {gpu_duration2:.2f} seconds")
+```
+
+    Correction: 100%|██████████████████████████████| 100/100 [00:17<00:00,  5.75%/s]
+
+
+    CPU correction time: 17.68 seconds
+
+
+    Correction: 100%|██████████████████████████████| 100/100 [00:08<00:00, 12.39%/s]
+
+
+    Cold GPU correction time: 27.42 seconds
+
+
+    Correction: 100%|██████████████████████████████| 100/100 [00:02<00:00, 44.18%/s]
+
+    Hot GPU correction time: 2.47 seconds
+
+
+    
+
+### Minimum feature size
+
+We've added tools to check and enforce minimum feature sizes of devices you are working with. The `Device.check_feature_size` and `Device.enforce_feature_size` methods help ensure your designs meet sizing requirements. While these tools are not full design rule checking (DRC) solutions, we believe they can be useful early in the design process.
+
+```python
+import prefab as pf
+
+star = pf.shapes.star(width=500, num_points=4)
+star.plot()
+
+star.check_feature_size(min_feature_size=30, strel="disk")
+star_e = star.enforce_feature_size(min_feature_size=30, strel="disk")
+star_e.plot()
+```
+
+    Feature size check with minimum size 30 using 'disk' structuring element resulted in a Hamming distance of: 702
+
+
+
+
+
+    <Axes: xlabel='x (nm)', ylabel='y (nm)'>
+
+
+
+
+    
+![png](prefab-v1.1.0_files/prefab-v1.1.0_7_2.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_7_3.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_7_4.png)
+
+### 3D structures
+
+We have introduced the `Device.to_3d` and `Device.to_stl` methods to convert your 2D device structures into 3D arrays or STL files. These features are particularly useful for simulating processes with angled sidewalls. For more details on working with angled sidewalls, refer to this [notebook](../../examples/3_sidewall_angle.ipynb).
+
+The `Device.plot` method displays the upper and lower edges of the sidewall-angled device structure. These two new methods use the edges as boundaries for the 3D extrusion.
+
+```python
+import prefab as pf
+
+target = pf.shapes.target(width=1000, arm_width=200)
+target_p = target.predict(model=pf.models["ANT_SiN_ANF1_d1"], binarize=True)
+target_p.plot()
+
+target_p_3d = target_p.to_3d(thickness_nm=400)  # visualizer to come soon
+target_p.to_stl(thickness_nm=400)  # this will create a 3D STL file you can inspect
+```
+
+    Prediction: 100%|██████████████████████████████| 100/100 [00:04<00:00, 22.84%/s]
+
+
+    Saved Device to 'prefab_device.stl'
+
+
+
+    
+![png](prefab-v1.1.0_files/prefab-v1.1.0_9_2.png)
+
+### 3rd-party libraries
+
+PreFab should seamlessly fit into your existing design flow. As such, we're adding tools to read and write from/to common libraries such as [Tidy3D](https://www.flexcompute.com/tidy3d/) and [gdsfactory](https://gdsfactory.github.io/gdsfactory/).
+
+This first example shows how to read a gdsfactory component, correct it using PreFab, and then convert it back to a gdsfactory component.
+
+```python
+import gdsfactory as gf
+import prefab as pf
+
+component = gf.components.triangle(x=1, xtop=0, y=2, ybot=0, layer="WG")
+component.plot()
+device = pf.read.from_gdsfactory(component)
+
+device_c = device.correct(model=pf.models["ANT_NanoSOI_ANF1_d10"], binarize=True)
+component_c = device_c.to_gdsfactory()
+component_c.plot()
+```
+
+    Correction: 100%|██████████████████████████████| 100/100 [00:02<00:00, 46.44%/s]
+
+
+
+    
+![png](prefab-v1.1.0_files/prefab-v1.1.0_11_1.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_11_2.png)
+
+This second example shows how to read a Tidy3D simulation, correct the structure using PreFab, and then send it back to a Tidy3D simulation.
+
+```python
+import prefab as pf
+import tidy3d as td
+
+freq0 = td.C_0 / 0.75
+arm1 = td.Structure(
+    geometry=td.Box(center=(0, 0, 0), size=(0.1, 0.75, 0.22)),
+    medium=td.Medium(permittivity=2.0),
+)
+arm2 = td.Structure(
+    geometry=td.Box(center=(0, 0, 0), size=(0.75, 0.1, 0.22)),
+    medium=td.Medium(permittivity=2.0),
+)
+source = td.PointDipole(
+    center=(-0.75, 0, 0),
+    source_time=td.GaussianPulse(freq0=freq0, fwidth=freq0 / 10.0),
+    polarization="Ey",
+)
+monitor = td.FieldMonitor(
+    size=(td.inf, td.inf, 0),
+    freqs=[freq0],
+    name="fields",
+    colocate=True,
+)
+sim = td.Simulation(
+    size=(2, 2, 3),
+    grid_spec=td.GridSpec.auto(min_steps_per_wvl=100),
+    structures=[arm1, arm2],
+    sources=[source],
+    monitors=[monitor],
+    run_time=120 / freq0,
+)
+
+sim.plot_eps(z=0)
+
+device = pf.read.from_tidy3d(tidy3d_sim=sim, eps_threshold=1.5, z=0)
+device.plot()
+
+device_p = device.predict(model=pf.models["ANT_NanoSOI_ANF1_d10"], binarize=True)
+structure_p = device_p.to_tidy3d(eps0=2.0, thickness=1.5)
+
+sim_p = sim.updated_copy(structures=[structure_p])
+sim_p.plot_eps(z=0)
+```
+
+    Prediction: 100%|██████████████████████████████| 100/100 [00:10<00:00,  9.26%/s]
+
+
+
+
+
+    <Axes: title={'center': 'cross section at z=0.00'}, xlabel='x', ylabel='y'>
+
+
+
+
+    
+![png](prefab-v1.1.0_files/prefab-v1.1.0_13_2.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_13_3.png)
+
+![png](prefab-v1.1.0_files/prefab-v1.1.0_13_4.png)
+
+## What's next
+
+We're excited about the future of PreFab and how we can help you gain more control over your nanofabrication process. Here are our key focus areas for the upcoming months:
+
+- **Performance Enhancements**: We are implementing several improvements to accelerate predictions, particularly for larger devices.
+- **Expanding Model Library**: We are adding more models to our platform. If you have a specific nanofabrication process in mind, please reach out to us!
+- **Innovative Usage Methods**: We have exciting ideas to make PreFab even more powerful, particularly within the design optimization process. Look out for more updates on this front.
+- **Code Quality**: We are working on improving the code quality of PreFab to make it more robust and easier to maintain. This will lay the foundation for future development and collaboration.
+- **Community Engagement**: We value your input and are eager to hear your ideas and suggestions. Please reach out to us at [support@prefabphotonics.com](mailto:hi@prefabphotonics.com) with your feedback.
+
+Thank you for your support, and happy designing!