Design SuperInductor junction for Fluxonium devices

[nikosavola]

Description

At APS March meeting 2023 there was large interest in using KQCircuits for Fluxoniums designs. Would be nice to have one example qubit with a Junction array.

Use case

Use KQC for designing Fluxonium devices.

[nikosavola]

I am happy to help if anyone is interested in adding a superinductor array to, for example, Double Pads.

[qpavsmi]

Prerequisites

KQCircuits GUI installation required

Issue description

The task is to implement a simple version of the SuperInductor junction into the KQCircuits library. The junction will then be used by qubits already present in the KQCircuits library, such as Double Pads. The geometry of the SuperInductor junction should be parametrised so that certain features in the junction could be tuned on-the-fly without rewriting the code.

Read more:

Planat, Luca et al. ‘A photonic crystal Josephson traveling wave parametric amplifier’, Phys. Rev. X, vol: 10, Apr. 2020, doi: 10.1103/PhysRevX.10.021021

Bao, Feng et al. ´Fluxonium: An Alternative Qubit Platform for High-Fidelity Operations´, Phys. Rev. X, vol: 129, Jun. 2022, doi: 10.1103/physrevlett.129.010502

How to get started

We recommend getting started by copying an existing junction in KQCircuits and using that as a template for the new SuperInductor junction. Let's copy manhattan.py into the same folder junctions and rename it super_inductor.py. Rename the name of the class in the python file from Manhattan to SuperInductor.

Now when you start KLayout, change the Libraries selection to Junction Library - Library for junctions.. You should see the new SuperInductor entry in the library list. Drag-and-drop that entry into the layout, then press F2 and * to center the view and unhide the cells. You should be able to see geometry for the Manhattan junction, but under the Super Inductor name.

You can also view the current state of the SuperInductor by using the create_element_from_path.py utility, which can be integrated within an IDE. More instructions on how to set it up in the script's comments.

Next, open kqcircuits/junctions/__init__.py and include Super Inductor entry in the junction_type_choices list. After restarting KLayout, drag-and-drop some qubit into the layout, for example Double Pads. Now the Junction Type parameter should have the Super Inductor junction as an option.

The rest of the work is to implement klayout_package/python/kqcircuits/qubits/super_inductor.py according to the specifications outlined in below chapter. Some main take-aways from the Manhattan code:

• The SuperInductor (previously Manhattan) class is a subclass of the Squid class, which inherits the loop_area parameter. We recommend using that parameter in your design.
• All of the geometry generation happens under the build method. All other methods present in the code are called from the build method.
• In the header of the class we define parameters for the element, e.g. finger_overshoot = Param(pdt.TypeDouble, "Length of fingers after the junction.", 1.0, unit="μm").
  • Pay attention that unit argument makes sense for parameters you define, for example "µm"
  • These parameters can then be accessed via self, e.g. self.finger_overshoot
  • SuperInductor inherits the junction_width parameter from Junction class, so don't forget to use it
  • If you define a pdt.TypeList type parameter, make sure to cast all elements to appropriate datatypes because they are interpreted as strings when changed from GUI. (e.g. float(self.ground_gap[0])).
• To produce geometry, first define a shape by using pya.DPolygon or pya.DBox. Then convert the shape into a pya.Region with region = pya.Region(shape.to_itype(self.layout.dbu)). If you have multiple regions that possibly overlap, you can combine them into a single region using the + operator: region = region1 + region2. Alternatively, if shapes are in the list shapes, you can use region = pya.Region(shapes).merged(). Finally, add the region into some of the junction cell's layers, let's say "SIS_junction" with self.cell.shapes(self.get_layer("SIS_junction")).insert(region).
• Ports are used as reference points to connect components together within the chip. Add a port using self.add_port("port_name", port_origin, direction=port_direction), where port_origin is pya.DPoint and port_direction is pya.DVector. Direction helps to align a waveguide into the port. If you're not sure that you need the direction argument, it's fine not to use it.

For more information refer to the KLayout API and KQCircuits workflow advisory.

You can also reload the fluxonium placed on the layout after each code change: from KLayout top task bar choose KQCircuits > Reload libraries. This features is a bit buggy at the moment and might cause KLayout to crash.

Super Inductor design

The below specifications for the design are for the uninitiated. Similar design was used in
Vool, Uri et al. ‘Non-Poissonian Quantum Jumps of a Fluxonium Qubit due to Quasiparticle Excitations’, Physical review letters. vol: 113, 2014, doi: 10.1103/PhysRevLett.113.247001.
If you are familiar with Fluxoniums and what kind of Super Inductor junctions can work to implement such qubits, feel free to implement your own design. Just make sure the design is well parametrised and that it meets the Definition of done below.

The outline of the design is presented in this chart which we will further describe in text.

Super Inductor is an array of junctions (blue lines) connected by wires (red lines). Junctions should align to x-axis and wires to y-axis, and they should be orthogonal to each other. Sequence of junctions should form a line, with wires connecting them in the middle. Should the junction sequence make a bend, the wires can be placed somewhere not strictly in the middle - as long as they connect the two junctions. Junctions and wires should be placed in the "SIS_junction" layer.

On the left, opposite to the loop shape, there should be two wires connecting two junctions to form a SQUID loop area. Multiple SQUID loop areas should be placed in a sequence. From each end of the SQUID array there should be wires extending to some length.

We recommend to think of the Super Inductor construction as a set of line segments, where each line segment is populated by junctions along the line. If the line is diagonal, the wires should remain to be aligned with the y-axis and form a shape of stairs as they connect the junctions. On the sides of the Super Inductor there should be one junction enabling a U-turn of the junction sequence. See the below chart for line segment visualisation.

The junctions in the Super Inductor will be fabricated as so-called bridge-free Josephson junctions. For this we need shapes that are placed in the "SIS_shadow" layer. These shapes are visualised in the chart as pink rectangles, to the left and to the right of the wires, as well as pertruding from both ends of junctions. For wires, the undercutting regions should alternate between being on the left or on the right of the wire. Consult the chart if the direction of the undercutting region is unclear in specific cases. Open the GDS file within attached ZIP file with KLayout for further reference (courtesy of Vladimir Milchakov). Here layer 1/0 would be SIS_junction and 2/0 would be SIS_shadow.

2_Stripline.zip

It's good to review during the development process how the Super Inductor looks like on a ready-made qubit like Double Pads. Make sure that the wires leading out of the Super Inductor have enough length. The origin (pya.DPoint(0,0)) of the Super Inductor cell should be the end of the south wire. Add a port called "common" with self.add_port("common", point), where point is located on the end of the north wire. Make sure that the origin and the "common" port are not exactly at the ends of their respective wires. Instead let the wire pertrude a bit beyond those points so that Super Inductor can reach inside the pads of the qubit.

Parameters of the Super Inductor design

This is our best guess on what features should be parametrised because the parameter set may vary depending on the implementation details.

1. Junction length and width. Let junction length be 5µm by default and width be tied to self.junction_width as inherited from the Junction class.
2. Wire length and width. By default, length should be smaller then junction length. If you want, you can leave wire length not to be parametrized and be dependent on 3. and 4.
3. Number of junctions in the Super Inductor, excluding the junctions forming the SQUID loops. Increasing this parameter should either cause the overall shape of the Super Inductor to be wider or decrease the wire length.
4. End points of "line segments", effectively defining the overall shape of the Super Inductor. Could also instead be dependent on wire length (2.) and 3.
5. SQUID loop area width and height. Notice that junctions and wires forming SQUID loops should have their lengths defined separately from other wires.
6. Number of SQUID loops in SQUID array.
7. Phase slip junction length. The center junction on the right hand side junction array should be shorter, as can be seen from the chart.
8. Lengths of the two wires sticking out of the SQUID array

This requirement does not need to be followed to the letter. It's good to parametrize as much as we can, but also we do not want to confuse the designer with too many parameter choices. It's good to be mindful if there are "magic" numbers in the code and what is the justification for them not being parametrised.

Definition of done

• When the Super Inductor junction is drag-and-dropped into the layout, it should show required design with no errors or failures. Same if it is run with create_element_from_path.py.
• Parameters can be changed from KLayout UI without it causing errors (if using reasonable values).
• Super Inductor junction should be selected for the Double Pads qubit and the Super Inductor geometry should match nicely with Double Pads geometry (use refpoints to align junction to qubits)
• Code should have sufficient docs: Super Inductor class should have a clear explanation, parameters should be well described.
• No tests needed for the junction element

Final note

I highly recommend to make a pull request early even if the code is not finished. PR can be created as early as when you simply create the super_inductor.py file. This gives us an opportunity to give feedback early and to guide the design process, and its also very illustrative to share code to show where you are stuck.

[hrahman12]

Hi I'm interested in working on this

[qpavsmi]

Hi I'm interested in working on this

Awesome, thank you for your interest! You can start working on the solution and once the solution is ready, create a pull request. During review we might give some suggestions to refine the solution, but once it is ready, we will assign you to this issue and mark it closed. Don't hesitate to make a pull request earlier rather than later so that we could have some time before the deadline to reiterate your solution from our feedback if needed.