gdsfactory / gdsfactory

python library to design chips (Photonics, Analog, Quantum, MEMs, ...), objects for 3D printing or PCBs.

gdsfactory 7.23.0

gdsfactory: An open source platform for end to-end chip design and validation.

Highlights:

• More than 1M downloads
• More than 50 Contributors
• More than 10 PDKs available

Gdsfactory is a Python library for designing chips (Photonics, Analog, Quantum, MEMs, and more), 3D printed objects, and PCBs. Here, you can code your hardware design in Python or YAML, perform verification (DRC, simulation, and extraction), and enable automated testing in the lab to ensure your fabricated chip meets your specifications.

We facilitate an end-to-end design flow for you to:

• Design (Layout, Simulation, Optimization): Utilize parametric cell functions in Python or YAML to define components. Test component settings, ports, and geometry to avoid unwanted regressions, and capture design intent in a schematic.
• Verify (DRC, DFM, LVS): Run simulations directly from the layout using our simulation interfaces, removing the need to duplicate geometry drawings. Conduct component and circuit simulations, study design for manufacturing, and ensure complex layouts match their design intent through Layout Versus Schematic verification.
• Validate: Define layout and test protocols simultaneously for automated chip analysis post-fabrication. This allows you to extract essential component parameters, and build data pipelines from raw data to structured data to monitor chip performance.

Your input: Python or YAML text. Your output: A GDSII or OASIS file for fabrication, alongside component settings (for measurement and data analysis) and netlists (for circuit simulations) in YAML.

We provide a common syntax for design (KLayout, gdstk, Ansys Lumerical, tidy3d, MEEP, MPB, DEVSIM, SAX, MEOW ...), verification, and validation.

Many foundries have gdsfactory PDKs available. Please to contact your foundry to access their gdsfactory PDK, as you will require an NDA:

• AIM photonics PDK
• AMF photonics PDK
• TowerSemi PH18 photonics PDK
• GlobalFoundries 45SPCLO Photonics PDK
• IMEC photonics PDK
• HHI Photonics PDK
• Compoundtek photonics PDK

There are some open source PDKs available without an NDA:

• GlobalFoundries 180nm MCU CMOS PDK (open source)
• SiEPIC Ebeam UBC PDK (open source)
• Skywater130 CMOS PDK (open source)
• VTT (open source)
• Cornerstone (open source)

You can also access:

• instructions on how to build your own PDK
• instructions on how to import a PDK from a library of fixed GDS cells

Getting started

• See slides
• Read docs
• 
• 
• See announcements on GitHub, google-groups or LinkedIn
• 
• 
• PIC training
• Online course UBCx: Silicon Photonics Design, Fabrication and Data Analysis, where students can use gdsfactory to create a design, have it fabricated, and tested.

Who is using gdsfactory?

Hundreds of organisations are using gdsfactory. Some companies and organizations around the world using gdsfactory include:

"I've used gdsfactory since 2017 for all my chip tapeouts. I love that it is fast, easy to use, and easy to extend. It's the only tool that allows us to have an end-to-end chip design flow (design, verification and validation)."

Joaquin Matres - Google

---

"I've relied on gdsfactory for several tapeouts over the years. It's the only tool I've found that gives me the flexibility and scalability I need for a variety of projects."

Alec Hammond - Meta Reality Labs Research

---

"The best photonics layout tool I've used so far and it is leaps and bounds ahead of any commercial alternatives out there. Feels like gdsfactory is freeing photonics."

Hasitha Jayatilleka - LightIC Technologies

---

"As an academic working on large scale silicon photonics at CMOS foundries I've used gdsfactory to go from nothing to full-reticle layouts rapidly (in a few days). I particularly appreciate the full-system approach to photonics, with my layout being connected to circuit simulators which are then connected to device simulators. Moving from legacy tools such as gdspy and phidl to gdsfactory has sped up my workflow at least an order of magnitude."

Alex Sludds - MIT

---

"I use gdsfactory for all of my photonic tape-outs. The Python interface makes it easy to version control individual photonic components as well as entire layouts, while integrating seamlessly with KLayout and most standard photonic simulation tools, both open-source and commercial.

Thomas Dorch - Freedom Photonics

Why use gdsfactory?

• It's fast, extensible and easy to use.
• It's free, as in freedom and in cost.
• It's the most popular EDA tool with a growing community of users and developers, and extensions to other tools.

Gdsfactory is really fast thanks a C++ library for manipulating GDSII objects. You will notice this when reading/writing big GDS files or doing large boolean operations.

Benchmark	gdspy	gdsfactory	Gain
10k_rectangles	80.2 ms	4.87 ms	16.5
boolean-offset	187 μs	44.7 μs	4.19
bounding_box	36.7 ms	170 μs	216
flatten	465 μs	8.17 μs	56.9
read_gds	2.68 ms	94 μs	28.5

Contributors

Thanks to all the contributors that make this awesome project possible!

gdsfactory's Issues

confusing name for cross_section kwarg

many functions (straight, bend ...) for component and routing have a cross_section setting, as well as **kwargs for customizing the cross_section

this could be more explicit to avoid confusion

we have 3 options:

1. Accept only cross_section_factory. In that case maybe we should rename cross_section to cross_section_factory #269
2. Accept only CrossSection and remove **kwargs. See branch https://github.com/gdsfactory/gdsfactory/tree/472_cross_section_only
3. Accept both, and check if cross_section is callable or not #268 (this is our plan on record)

What do you think?
@tvt173
@flaport

electronics co-simulation plugin

it would be great to interface with a time domain capable simulator

https://github.com/TeledyneLeCroy/SignalIntegrity

colab does not find klayout layermap file lyp

How can we make colab find the klayout lyp?

so we get nice colors by default

@flaport
@proppy
@tvt173

write_sparameters_meep running in multi-process using multiple cores

one way to make this work is to write a script to disk and then Popen a process

Similar to what Derek does in picwriter
https://github.com/DerekK88/PICwriter/blob/master/picwriter/picsim.py

related to #124 and also suggested by @smartalecH and @simbilod

Let me know what you think
Joaquin

tidy3d plugin not finding the right waveguide modes

The waveguide modes have wrong index and mode profiles

near2far meep grating coupler example

How could we add a near2far grating coupler example to notebooks/gdsfactory/plugins/meep/002_gratings.ipynb ?

@simbilod

klayout Salt package for gdsfactory

How can we enable a klayout, similar to this one?

That way we can bring in the klayoutGUI nice features directly into klayout without having to run
gf tool install

we can register the pacakge here

For managing private klayout packages one can also use this kgit

Don't pin dependency versions in setup.py

Hey Joaquin,

Installing gdsfactory in an existing python environment is a pain. This is because all dependencies of gdsfactory are pinned to an exact version. In my opinion this is not a good system for a library, as we need to be able to place it in many different contexts.

In my opinion you should pin dependency versions in your requirements.txt but NOT in your setup.py.

i.e. requirements.txt is your 'recommended environment' whereas in setup.py you should have minimal dependencies such that your library can easily be installed in other environments. And yes, that might break things sometimes but it's the end user's choice to use/not use your requirements.txt.

Let me know what you think.

recognize hierarchical components in SiEPIC tools verification flow?

SiePIC tools working now. which is nice for verification (find unconnected pins, extract interconnect netlist ..)

See gdsfactory/samples/pdk/fab_a.py

How can we recognize hierarchical components?

enable export TECH into YAML

Omegaconf does now support Tuple[Tuple] yet

omry/omegaconf#757

options to fix it:

• Layer can be a dataclass

enable different port naming conventions

There are many port naming conventions in photonics

one thing would be interesting is trying to support different port naming conventions for component building and simulations

current plugins such as gmeep only support o1, o2, o3 ... port naming convention

only works for python3.7

type annotations work only for Python>=3.7
https://www.python.org/dev/peps/pep-0563/

for python3.8 it would work once pip install klayout works for python3.8

Connecting two labels in GDS layout

Hi Team ,

I have below requirement where i need to connect two "labels" in GDS :

1. I have two design gds - lets say A.gds and B.gds - and they have pin A1,A2 and B1,B2 respectively.
2. I need to create a top.gds comprising of A.gds and B.gds where i need to connect A1-B1 , A2-B2 with some layer without overlap.

Can you please guide if its possible and how to do it ?

Thanks & Regards

enable custom fonts in polygon text

it would be nice if the user could easily load a custom font to use for polygon text.

currently the text() function references private variables for character glyphs, widths, and indents. it would be nice if it was easier to do this, maybe from a library of gds characters.

relevant to
heitzmann/gdspy/issues/207

test file hash seem to change from Tox, pytest and github actions

after freezing the timestamp to a fixed date, we should get deterministic hashses

it would be great having a deterministic hash and be able to activate the tests in

pp/tests/test_hash.py

binder runs quite slow

I noticed that binder runs now quite slow, any ideas why?

@tvt173
@proppy
@flaport

dispersive materials seem to be missing in tidy3d plugin plot_eps

see gdsfactory/simulation/tidy3d/fixme/plot_material.py

pydocstyle

Clean docstrings and have pydocstyle passing so when you run

pydocstyle gdsfactory

there are no errors

validate component arguments with pydantic

How can we validate component arguments with pydantic?

from pp.component import Component
from pp.cell import cell_with_validator


@cell_with_validator
def array(component: Component, n: int = 2, pitch: float = 20.0) -> Component:
    print(type(component))
    c = Component()
    for i in range(n):
        ref = component.ref()
        ref.x = i * pitch
        c.add(ref)
        for port in ref.get_ports_list():
            c.add_port(f"{port.name}_{i}", port=port)
    return c


if __name__ == "__main__":
    import pp

    c1 = pp.c.pad()
    c2 = array(component=c1, pitch=150, n=2)
    c2.show()

implement route optimizer

How can we improve routing functions?

• support global router
• support auto-routing with arbitrary directions, at the moment groups of routes need to have the same angle.

See gdsfactory/fixme/router.py and gdsfactory/fixme/router2.py

we could also leverage some of the routing algorithms from VLSI or PCB routing

• https://github.com/gdsfactory/kfactory/blob/auto-router/src/kfactory/routing/auto_router.py
• https://codeberg.org/LibrEDA/mycelium-router/src/branch/main/src/maze_router
• https://github.com/vygr/Python-PCB
• https://github.com/freerouting/freerouting
• https://github.com/jrialland/python-astar
• https://github.com/jamesbowman/cuflow
• https://codeberg.org/tok/librecell/src/branch/master/librecell-layout/lclayout/router.py
• https://codeberg.org/tok/librecell/src/branch/master/librecell-layout/lclayout/graphrouter/pathfinder.py
• https://github.com/hgroller/KlayoutNetworkX
• https://github.com/gsteixeira/python-astar/blob/main/examples/basic.py
• https://github.com/zhm-real/PathPlanning

@jaspreetj

calculate sparameters at multiple wavelengths for tidy3d plugin

How can we calculate the Sparameters at more than 1 wavelength?

see example in gdsfactory/simulation/gtidy3d/get_results.py

how to replace 2x90deg bends with 1x180deg bend in gf.routing.round_corners?

for euler bends, allowing round_corners to leverage 180 degree bends would save some space

p1 = pp.Path()
p1.append([pp.path.euler(angle=90), pp.path.euler(angle=90)])
p2 = pp.path.euler(angle=180)

x = pp.cross_section()

c1 = pp.path.extrude(p1, x)
c1.name = "two_90_euler"
c2 = pp.path.extrude(p2, x)
c2.name = "one_180_euler"
c1.add_ref(c2)
c1.show

schematic capture

How can add schematic capture?

ideally we would enable a schematic driven flow

for that we only need instances and routes from our netlist driven flow

we convert the netlist from YAML into an XML
https://github.com/TeledyneLeCroy/SignalIntegrity

so we allow both GUI and code schematic driven flows

foundry PDKs

one of the biggest limiting factors for a larger adoption of gdfactory is that we don't provide official PDK foundry support

what is the best way to share PDKs for different foundries?

Most fabs support cadence and synopsis PDKs at the moment, and it would be great to enable an open source layout, simulation and verification alternative, much nicer to use and python native.

maybe you can also help us gain some traction by asking your partner fabs to work with us on this. Feel free to share or comment this post.

I see 3 options:

1. In the ideal case the foundry makes their PDK open source. See for example google/skywater130 pdk This enables a large, community built and maintained PDK. No NDAs required for accessing PDK technology needed for building chips. For protecting some particular cells, foundry can always use some black boxed cells, that can be replaced by the foundry before fabrication on the fab side.
2. Create a private Git repository, that the foundry controls access, and only users with valid NDA get granted permission to access.
3. Foundry builds and maintains a gdsfactory PDK for their technology and they share it with their users. This is the least collaborative approach and does not allow users to share improvements, as the information only flows in one direction. This is option is based on the current model and requires extra effort from the foundry to build and maintain the PDK. Therefore PDKs are hard to maintain, hard to track changes and hard to improve.

what do you think?

@QuantamHD
@mithro
@thomasdorch

get_netlist does not work with component arrays

When calling get_netlist() on a component generated with gdsfactory.components.array(), it fails with the error AttributeError: 'CellArray' object has no attribute 'ports' while the function collects lower-level ports. The underlying error seems to be that a gdspy CellArray is placed directly as a reference within the array component. I think we need to implement a corresponding ComponentArray type if we want them to be fully compatible with gdsfactory.

automatic detect routing crossings and place a waveguide crossing instead

Maybe call the function get_route_with_crossings or something like that

Add support for Google's open source 130nm PDK manufacturable at SkyWater

In 2020, Google in collaboration with SkyWater released a fully open source PDK for Skywater's 130nm process technology under an Apache 2.0 license. It can be found at http://github.com/google/skywater-pdk with documentation at https://skywater-pdk.readthedocs.io/ -- The announcement video can be found at https://www.youtube.com/watch?v=EczW2IWdnOM&t=152s

It would be awesome for gdsfactory to ship with support for this PDK! There are a number of efforts to make sure that KLayout is well supported in the PDK - see https://github.com/laurentc2/SKY130_for_KLayout and https://github.com/mabrains/sky130_klayout_pdk

FYI - SkyWater also does a lot of work in the photonics space.

enable `conda install gdsfactory`

I would love to be able to conda install gdsfactory. it would greatly simplify installation on windows, where you typically need to conda install gdspy or have vscode build tools available for the full installation to work without issue

gdsfactory seems to depends on multiple versions of the `panel` package

Installing with python -m pip install gdsfactory trigger the following install:

Collecting panel>=0.8.0
  Downloading panel-0.12.5-py2.py3-none-any.whl (12.9 MB)
     |████████████████████████████████| 12.9 MB 28.5 MB/s 
  Downloading panel-0.12.4-py2.py3-none-any.whl (12.9 MB)
     |████████████████████████████████| 12.9 MB 31.4 MB/s 
  Downloading panel-0.12.3-py2.py3-none-any.whl (12.8 MB)
     |████████████████████████████████| 12.8 MB 828 kB/s 
  Downloading panel-0.12.2-py2.py3-none-any.whl (12.8 MB)
     |████████████████████████████████| 12.8 MB 40.2 MB/s 
  Downloading panel-0.12.1-py2.py3-none-any.whl (12.8 MB)
     |████████████████████████████████| 12.8 MB 37.9 MB/s 
  Downloading panel-0.12.0-py2.py3-none-any.whl (9.9 MB)
     |████████████████████████████████| 9.9 MB 14.2 MB/s 
  Downloading panel-0.11.3-py2.py3-none-any.whl (9.0 MB)
     |████████████████████████████████| 9.0 MB 28.5 MB/s 
  Downloading panel-0.11.2-py2.py3-none-any.whl (9.0 MB)
     |████████████████████████████████| 9.0 MB 47.3 MB/s 
  Downloading panel-0.11.1-py2.py3-none-any.whl (8.8 MB)
     |████████████████████████████████| 8.8 MB 27.2 MB/s 
  Downloading panel-0.11.0-py2.py3-none-any.whl (8.8 MB)
     |████████████████████████████████| 8.8 MB 26.7 MB/s 
  Downloading panel-0.10.3-py2.py3-none-any.whl (8.1 MB)
     |████████████████████████████████| 8.1 MB 40.4 MB/s 

is that expected?

klive macro does not automatically start with klayout

klive does not automatically start with latest klayout installs

How can we make sure it starts when we open klayout

so you don't have to manually start it in the macros section

see code here
https://github.com/gdsfactory/gdsfactory/blob/master/gdsfactory/klayout/pymacros/klive.lym

enable tighter metal routes

The current routing algorithm does not allow for small "kinks" in the wire.
More precisely, for the current wiring algorithms (gf.routing.getroute() and gf.routing.get_bundle()), if the wire needs to make an S-bend, the lateral displacement of the wire must be GREATER than the wire width. This makes tight wiring and/or very painful.

import gdsfactory as gf

if __name__ == "__main__":
    c = gf.Component("mzi_with_pads")
    c1 = c << gf.components.pad()
    c2 = c << gf.components.pad()

    c2.movex(30)
    c2.movey(200)

    port1 = c1.ports["e2"]
    port2 = c2.ports["e4"]

    route = gf.routing.get_route(
        port1,
        port2,
        cross_section=gf.cross_section.metal1,
        width=50,
        bend=gf.components.wire_corner,
    )
    c.add(route.references)
    c.show()

Documentation links to source are broken

When clicking the link to [source] on any of the functions listed in the pp module, I get a 404 not found error. Not sure if this problem is present in other modules as well, or just this one

https://gdsfactory.readthedocs.io/en/latest/pp.html

toggle layers on/off interactively

There is a new plotting backend in gdsfactory 3.9.10 thanks to holoviews

it enables responsive plots even for the documentation

I would love to implement a legend and a way to toggle layers on/off

Related to issue
solgaardlab/dphox#2

connectivity cheks

We would like some way to look at our routing and verify that the connectivity is what is expected (i.e. some form of LVS). For example, we need to be able to check whether the wiring we generated does not have opens or unintended shorts.

Netlist tracing is currently not fully implemented or robust. In particular, the gf.Component.get_netlist() function does not implement fully netlist tracing. For example, if you connect two wires of different widths, or if many wires are connected to a single bus bar (very common for electrical wiring), the netlist tracer does not understand that the wires are the same net

• improve netlist extraction, to account for electrical connections. Maybe write a new netlist extractor? @tvt173

demo klayout LVS extraction:

• define layer stack and connectivity stack programatically PR
• make sure nets match design intend
• https://github.com/austinapatel/KLayout-Connection-Validator

Regarding/importing a GDS file to gdsfactory and creating array

Hi ,

I want to import an already created GDS file , and then create an array of the shapes that are inside the GDS.
Please let me know the relevant sections in the tutorial i should refer to. I was not able to locate the part of "import an already created GDS file" to gdsfactory.

Thanks

smarter or more configurable manhattan routes

How could we have smarter or more configurable manhattan routes?

"""
Manhattan routes sometimes have unnecessary crossings

How can we detect this crossings?

"""

import gdsfactory as gf

if __name__ == "__main__":
    c1 = gf.components.nxn(west=0, east=3)
    c2 = gf.components.nxn(west=3, east=0, wg_margin=3)

    c = gf.Component()
    c1_ref = c.add_ref(c1)
    c2_ref = c.add_ref(c2)
    c2_ref.movex(100)
    routes = gf.routing.get_bundle(
        ports1=c1_ref.get_ports_list(), ports2=c2_ref.get_ports_list()
    )

    for route in routes:
        c.add(route.references)
        print(route.length)
    c.show()

A possible solution is to use get_routes, where routes with an Sbend when there is not enough space for a manhattan route
But it would be nice to extend get_bundle and round corners to enable sbend routing

import gdsfactory as gf
    c1 = gf.components.nxn(west=0, east=3)
    c2 = gf.components.nxn(west=3, east=0, wg_margin=3)

    c = gf.Component()
    c1_ref = c.add_ref(c1)
    c2_ref = c.add_ref(c2)
    c2_ref.movex(100)
    # routes = gf.routing.get_bundle(
    #     ports1=c1_ref.get_ports_list(), ports2=c2_ref.get_ports_list()
    # )
    # for route in routes:
    #     c.add(route.references)

    routes = gf.routing.get_bundle_sbend(
        ports1=c1_ref.get_ports_list(), ports2=c2_ref.get_ports_list()
    )
    c.add(routes.references)

    c.show()

enable Sbend routing when we have no space for a manhattan route

Route manhattan sometimes does not fit a route.
it would be nice to enable Sbend routing for those cases in route_manhattan

import gdsfactory as gf
from gdsfactory.routing.manhattan import route_manhattan


if __name__ == "__main__":
    c = gf.Component()
    length = 10
    c1 = c << gf.components.straight(length=length)
    c2 = c << gf.components.straight(length=length)

    dy = 4.0
    c2.y = dy
    c2.movex(length + dy)

    route = route_manhattan(
        input_port=c1.ports["o2"],
        output_port=c2.ports["o1"],
        radius=5.0,
        with_point_markers=True,
    )

    c.add(route.references)

    c.show()

ideally we could pass and sbend function to apply for this cases

Remove triangle from requirements.txt

The new dependency on triangle makes gdsfactory very hard to install into a conda environment. Would it be possible to remove (make optional)?

fix mypy issues

Having clearly defined type annotations helps catch many errors on the code

it would be great having make mypy give no type errors.
currently we have > 900 errors

Another type checkers would be pytype, pyre ...

The circle is not smooth

circle = gf.components.circle(radius=r, angle_resolution=2, layer=(1, 0))

When the angular resolution is small enough, the arc is not very smooth

![image](https://user-images.githubusercontent.com/75530092/139408027-3b467928-3d4c-442c-b8d6-20294da31df2.png

)

extract hiearchical netlists

How can we extract hierarchical netlists?

For example, it would be nice to get the netlist of this mzi lattice hiearchically

@tvt173
@flaport

netlist visualization improvements

netlists could look prettier in some cases if we added the instance as a block with ports inside

@tvt173
@flaport

disconnected waveguides in some manhattan routes

How can we fix some disconnected waveguides in some manhattan routes?

"""
Some manhattan routes have disconnected waveguides

"""

import gdsfactory as gf


if __name__ == "__main__":
    c = gf.Component()
    # c1 = c << gf.components.straight_array(spacing=200)
    c1 = c << gf.components.straight_array(spacing=50)
    c2 = c << gf.components.straight_array(spacing=5)

    c2.movex(200)
    c1.y = 0
    c2.y = 0

    routes = gf.routing.get_bundle_path_length_match(
        c1.get_ports_list(orientation=0),
        c2.get_ports_list(orientation=180),
        end_straight_length=0,
        start_straight_length=0,
        separation=50,
        radius=10,
        # radius=3 # smaller radius works
        enforce_port_ordering=False
    )

    for route in routes:
        c.add(route.references)

    c.show()

TE0 |E| fields looks like TE1

In the mpb plugin tutorial

The effective index looks correct for the first order TE mode TE0

However the |Ey| field for TE0 is much smaller than |Ex|, which is weird for a TE mode, so the total |E| field profile looks like TE1

@smartalecH and Simon @simbilod , let me know what you think

better serialization

based on #178

• using a package like orjson to do json serialization of the arguments
• any custom class needing to be serialized as an arg should have a custom serializer explicitly defined
• if an arg does not have an associated serializer, raise a warning and name the component with a UID instead. this will still let the user give arbitrary arguments to their component functions, and it will still ensure there are no dangerous cache issues. but, if the user wants deterministic names, they will need to go through the extra effort of adding a serializer to their custom class (or use a dataclass instead, which is automatically serializable by orjson)

support different port naming conventions

some functions, like meep and tidy3d write sparameters assume the o1, o2, o3 ... port names.it would be great to enable other port naming conventions.

Here are some other port conventions

• Siepic pdk uses opt1, opt2, opt3
• IPKISS2 uses E0, W0, N0, N1
• IPKISS3 uses in0, in1, out1, out0

Geometry import

Rather than export to an HDF5 file...

gdsfactory/gdsmp/sim.py

Line 18 in f47be48

def export_component_to_hdf5(filename, component, mstack, boolean_operations):

I would instead directly import the geometry using prism objects. Since you already have the polygon information from the gds "formalism", it's easy to import those.

This allows you to easily use dispersive materials, doesn't involve an extra layer of interpolation, and can even leverage objects with sidewall angles.

plugins

How can we extend gdsfactory plugins?

• pyspice demo.
• data analysis plugin
• litho plugin
• particle swarm optimization
• Lumerical ansys
  • Lumerical mode / eme plugin
  • Lumerical Device plugin
  • Add support / examples for lumerical layer builder

Done

• lumerical interconnect.
• devsim demos

Someday

enable more complex routing

• https://gitlab.lip6.fr/vlsi-eda/coriolis
• https://codeberg.org/LibrEDA/mycelium-router

enable schematic capture/electronics co-simulation

• https://github.com/TeledyneLeCroy/SignalIntegrity

@mgao-Ansys
@Zeqin-Lu
@121comeon
@thomasdorch
@jaspreetj

Bug with pydantic when extending_ports on some components

When extending ports on some multi-port components, pydantic throws an error.

Code:

c = gf.components.crossing()
p = 3
c = gf.add_padding_container(c, default=0, top=p, bottom=p)
df = write_sparameters_meep(c, overwrite=True, animate=False)

Traceback:

Traceback (most recent call last):
  File "test_write_sparameters_meep.py", line 59, in <module>
    test_sparameterNxN_crossing(None)
  File "test_write_sparameters_meep.py", line 36, in test_sparameterNxN_crossing
    df = write_sparameters_meep(c, overwrite=True, animate=False)
  File "pydantic/decorator.py", line 39, in pydantic.decorator.validate_arguments.validate.wrapper_function
    import itertools
  File "pydantic/decorator.py", line 133, in pydantic.decorator.ValidatedFunction.call
    func.__dict__.update(kw)
  File "pydantic/decorator.py", line 200, in pydantic.decorator.ValidatedFunction.execute
    """
  File "/home/simbil/Github/gdsfactory/gdsfactory/simulation/gmeep/write_sparameters_meep.py", line 404, in write_sparameters_meep
    **settings,
  File "pydantic/decorator.py", line 39, in pydantic.decorator.validate_arguments.validate.wrapper_function
    import itertools
  File "pydantic/decorator.py", line 133, in pydantic.decorator.ValidatedFunction.call
    func.__dict__.update(kw)
  File "pydantic/decorator.py", line 200, in pydantic.decorator.ValidatedFunction.execute
    """
  File "/home/simbil/Github/gdsfactory/gdsfactory/simulation/gmeep/write_sparameters_meep.py", line 270, in sparameter_calculation
    **settings,
  File "pydantic/decorator.py", line 39, in pydantic.decorator.validate_arguments.validate.wrapper_function
    import itertools
  File "pydantic/decorator.py", line 133, in pydantic.decorator.ValidatedFunction.call
    func.__dict__.update(kw)
  File "pydantic/decorator.py", line 200, in pydantic.decorator.ValidatedFunction.execute
    """
  File "/home/simbil/Github/gdsfactory/gdsfactory/simulation/gmeep/get_simulation.py", line 131, in get_simulation
    if extend_ports_length
  File "/home/simbil/Github/gdsfactory/gdsfactory/cell.py", line 166, in _cell
    component = func(*args, **kwargs)
  File "pydantic/decorator.py", line 39, in pydantic.decorator.validate_arguments.validate.wrapper_function
    import itertools
  File "pydantic/decorator.py", line 133, in pydantic.decorator.ValidatedFunction.call
    func.__dict__.update(kw)
  File "pydantic/decorator.py", line 200, in pydantic.decorator.ValidatedFunction.execute
    """
  File "/home/simbil/Github/gdsfactory/gdsfactory/components/extension.py", line 154, in extend_ports
    layer=port.layer,
  File "/home/simbil/Github/gdsfactory/gdsfactory/cell.py", line 166, in _cell
    component = func(*args, **kwargs)
  File "pydantic/decorator.py", line 39, in pydantic.decorator.validate_arguments.validate.wrapper_function
    import itertools
  File "pydantic/decorator.py", line 132, in pydantic.decorator.ValidatedFunction.call
    func.__module__ = getattr(self, 'module', callermodule)
  File "pydantic/decorator.py", line 129, in pydantic.decorator.ValidatedFunction.init_model_instance
    callermodule = '?'
  File "pydantic/main.py", line 406, in pydantic.main.BaseModel.__init__
pydantic.error_wrappers.ValidationError: 1 validation error for Straight
cross_section
  none is not an allowed value (type=type_error.none.not_allowed)

Elapsed run time = 0.0665 s

Also happens with other non-straight components like coupler

document interconnect Lumerical Ansys gdsfactory plugin

it would be great having a notebook tutorial in the simulations section that shows how to use the interconnect plugin

#237