Videos

Videos#

Sign up and invite your team#

  • Signing Up for GDSFactory+

    • Begin by signing up as an Organization Admin.

    • The first person in the organization to sign up should be the Organization Admin.

    • Organization Admins can manage users and invite team members.

  • Inviting Team Members

    • Use the invitation system to seamlessly add colleagues to your organization.

    • Invitations ensure that users are automatically linked to your organization upon signup.

  • How to Send an Invitation

    • Navigate to the Invitations tab in your dashboard.

    • Click the New Invitation button.

    • Enter the recipient’s email address.

    • Assign their role:

      • Admin: Manage organization users.

      • User: Access resources within the organization.

    • Click Invite to send the invitation.

  • What Happens After Sending an Invitation

    • The recipient receives an email with a signup link.

    • Clicking the link redirects them to the GDSFactory+ sign-up page.

    • After signing up, they are automatically added to your organization.

    • If the invitation email isn’t visible, remind your colleague to check their spam or junk folder.

  • Final Steps

    • Once your team is set up, they can start accessing resources and collaborating.

    • Organization Admins can manage roles and permissions to ensure efficient teamwork.

Install GDSFactory+ in VSCode#

If you only plan to use the cloud workspaces, you cam skip this part.

  • Steps to install the extension:

    • Open Visual Studio Code.

    • Navigate to the Extensions tab (icon with four squares) and install the GDSFactory+ extension

  • Verifying the installation:

    • Check for new menu items PDK and DRC on the left menu bar after restarting.

    • If these appear, the extension has been installed successfully.

  • Setting up the API key:

    • Go to the GDSFactory+ website and navigate to the API Keys section.

    • Create a new API key by clicking “Create New API Key” and naming it (e.g., my api key).

    • View and copy the generated API key using the eye icon.

    • In VS Code, click the PDK icon on the left menu bar.

    • Open Settings, select “Edit Global Settings,” and paste the API key in the key field.

    • Reload window.

    • Make sure you open a GDSFactory+ project for the extension to work properly.

Uploading Private Python Packages to a Private Package Index#

This video is only needed if you want to upload private PDKs from foundries.

  • Demonstration of uploading private Python packages to an organization’s private package index.

    • Example used: a PDK (Process Design Kit) package for demopdk.

    • Purpose: Streamline workflows and maintain security across projects.

  • Uploading the Package

    • Navigate to the private package index.

    • Upload the wheel (.whl) file for the package, e.g., DemoPDK.

    • Once uploaded, the package becomes immediately available for other projects.

  • Tips for Compatibility

    • Some packages require different wheel files based on:

      • Operating system (Windows, macOS, Linux).

      • Python version.

    • Upload multiple wheel files to ensure compatibility across operating systems.

  • Using the Uploaded Package

    • Open a demo project that depends on DemoPDK.

    • Check pyproject.toml to verify DemoPDK version (e.g., 0.12.4) is correctly specified.

    • Open the GDSFactory+ app:

      • It detects project dependencies.

      • Prompts to configure the environment.

      • Downloads and installs the necessary packages from the private index.

  • Conclusion

    • Successfully uploaded and utilized a private package.

    • Maintains package security and simplifies management across the organization.

Create and manage cloud workspaces#

If you plan to use the Local VSCode extension, you can skip this part.

  • Introduction to Workspaces

    • Learn how to create and manage your workspaces on the GDSFactory+ dashboard.

    • Workspaces allow you to edit projects connected to your GitHub account.

  • Before You Begin

    • Go to the Dashboard tab and connect your GitHub account.

    • This connection enables you to create workspaces for your projects.

    • In this example, the organization is “GDSFactoryPlus.” You will see your organization’s name instead.

    • Note: To access projects, you must be an organization owner. Contact your organization owner if needed.

  • Making Projects Visible

    • A project must have the “GFP” topic added to appear on the GDSFactory+ dashboard.

    • To add the topic:

      • Navigate to the project’s Settings on GitHub.

      • Find the Topics section.

      • Add “GFP” as a topic.

  • Creating a Workspace

    • Enter a name for your workspace and select the GitHub project you’d like to edit.

    • Example: Create a workspace named john and choose an open-source project, such as Cornerstone Silicon 220 nm PDK.

  • Workspace Setup

    • Workspace setup takes about a minute and progresses through these statuses:

      • Starting

      • Pending

      • Activated

      • Running

    • Once ready, the dashboard displays:

      • Workspace Name

      • Associated Project

      • Generated URL to access the workspace

      • Status

      • Owner

      • Age of the workspace

    • To remove a workspace, click the trash icon.

      • Important: Sync your work before deleting, as this action is irreversible.

  • Accessing Your Workspace

    • Click the URL in the dashboard or open it in a new browser tab.

    • Once inside, begin working on your project.

PDK explorer#

  • Introduction to Browsing Components

    • Learn to browse both Project Components and Foundry Components using the PDK Explorer.

    • The PDK tab organizes components, with Project Components at the top and Foundry Components at the bottom.

  • Review Components

    • Zoom in on components for detailed examination.

    • Use the ruler to measure distances between elements.

    • Clear rulers and toggle layers on or off as needed.

  • Exploring Project Components

    • Click on any Project Component to view its details.

    • Access various options depending on the component, such as:

      • GDS File: View the design layout.

      • Schematic: Open the schematic editor to define or modify circuits.

      • Edit: Update component details or source code.

      • Logs: Review design logs.

  • Working with Schematics

    • Open the schematic editor to define or refine circuits.

    • Ensure that your layout implementation matches the intended design.

    • Modify source code, update schematics, or view the GDS layout as needed.

  • Viewing Components Side by Side

    • Drag and drop to open multiple views simultaneously.

    • Example: Place the layout on the right and the schematic on the left for better context.

Create new schematics#

  • Introduction to Schematic-Driven Layout

    • Learn to create a schematic-driven layout using the PDK tab and schematic editor.

    • This method ensures your layout implementation aligns with the schematic design.

  • Creating a New Project Component

    • Click the PDK tab and then the + button to create a new Project Component.

    • Choose Schematic for circuits and name it, e.g., rings_filter.

    • Save the schematic using Control+S or File > Save to ensure it appears in the Project Component list.

  • Opening the Schematic Editor

    • Click the Schematic symbol on the left to open the editor.

    • Press H or ? to view all available commands.

  • Adding Instances

    • Press I to add instances of components. For example:

      • Add ring_single_sc and name it R1.

      • Add another ring_single_sc and name it R2.

    • Save the schematic and open the layout side by side for better visibility.

    • Initially, components will overlap as no placements or connections are defined.

  • Defining Connections

    • Open the schematic view and press L to create links between components.

    • Press E to edit the links and finalize them with Enter.

    • Save the schematic and use Zoom Fit to view the connected components.

  • Refining the Design

    • Modify the size or placement of components like R2 and save the changes.

  • Adding Ports

    • Press P to create ports, naming them, e.g., O1 (input) and O2 (output).

    • Use L to link the ports, establishing input and output connections.

    • Enable Show Ports to visualize the ports and verify the setup.

  • Running Circuit Simulations

    • Run circuit simulations with options such as:

      • Exporting to a Cadence Spectre netlist.

      • Running simulations in a Jupyter Notebook.

      • Performing simulations locally or remotely.

    • For this demonstration, run the simulation locally and view the results.

  • Defining Routed Connections

    • To use routed connections:

      • Break the existing link by pressing L and disconnecting it.

      • Define the placement of R2, e.g., move it 100 microns to the right.

      • Edit the link to create a route, customize it, and name it, e.g., route_1.

      • Save the schematic.

    • Routed connections adjust automatically if component placements change, keeping the design functional.

Automatic Routing#

  • Circuit Placement and Routing

    • Define circuit placements within the schematic

    • Modifying placements in the schematic automatically updates the routing

  • Convenient Instance Movement

    • Use the Move Instances option at the top left

    • Drag instances to the desired location, and routes follow automatically

    • Works with:

      • Single routes (e.g., lattice filter example)

      • Bundle routes (regenerates automatically when clicked on the component)

  • GDS Factory Plus Feature: ASTAR Bundle Router

    • Exclusive to GDS Factory Plus users

    • Allows dynamic instance movement while:

      • Automatically reconfiguring routes to avoid obstacles

      • Maintaining optimal connections

Create New Components in Python#

In this video, I’ll guide you through the process of creating new Components in Python.

  • Start by navigating to the PDK tab on the left side of the screen.

    • Click the + button to create a new Project Component.

    • Choose to create a Component in Python.

    • Name the file demo.

  • Create your first cell:

    • Click on the Add Cell button.

    • A Cell is a function that returns a Component.

    • A Component acts as an empty canvas where you can add polygons or instances of other components.

    • Name your cell demo1 and add a polygon.

  • Visualize your components side by side:

    • Drag the visualization window to the right to see the component’s code and GDS layout simultaneously.

  • Create a grid of components:

    • Add a new cell called demo2.

    • Use the gf.grid function to arrange multiple components in a grid layout.

    • Save the file to view the grid.

  • Optimize space with the pack function:

    • Add another cell named demo3.

    • Use the pack function to arrange multiple components efficiently, minimizing unused space.

    • Reuse components created earlier for the demonstration.

    • Save the file, and the packed layout will update automatically.

  • Import components from GDS files:

    • Create a new cell named demo4.

    • Use the import_gds function to import a layout from an existing GDS file.

    • Copy the file path using the “Copy Path” feature from your file manager and paste it into the code.

    • Save the file to visualize the imported GDS layout.

  • Add ports to your component:

    • Use the Component.add_port function to add ports for connectivity.

    • Define the port attributes:

      • Name: e.g., o1

      • Center: Specify the port’s center coordinates.

      • Width: Set the port’s width.

      • Orientation: Define the port’s direction.

      • Layer: Indicate the port’s layer.

In this video, we learned how to:

  • Create new Components in Python.

  • Add polygons and arrange components in a grid.

  • Optimize layouts with the pack function.

  • Import layouts from GDS files.

  • Add ports for component connectivity.

Run DRC on GDS Files#

  • Introduction to DRC in GDSFactory+

    • DRC (Design Rule Check) ensures your design meets required specifications, crucial in the semiconductor industry to avoid errors impacting the final product.

  • Step 1: Preparing Your GDS File

    • Create a GDS file directly in the platform or upload one from your system.

    • Open the GDS file within the platform. Multiple GDS files can be opened by clicking on each, appearing on the right side.

  • Step 2: Running the DRC

    • With the GDS file selected, click the “Check DRC” button.

  • Step 3: Reviewing DRC Results

    • After DRC completes, review errors in the DRC tab on the left or on the right panel.

    • The left DRC tab allows you to hover over each error type, showing the number of violations for each.

  • Step 4: Inspecting Specific Violations

    • Example: For a minimum width violation, clicking on it displays the affected component.

    • Minimum space violations show five errors; click through each to see detailed information.

Run DRC and review results locally#

  • Overview of Local DRC Execution and Review

    • Learn to run DRC (Design Rule Check) and review results locally on your computer.

  • Setting Up in VS Code

    • Open the VS Code Editor and start a notebook from the tutorials.

    • Import the Cornerstone PDK, an open-source PDK, and load the configuration.

    • Select the appropriate PDK and render the GDS file.

  • Running the DRC Check

    • Once the GDS is rendered, execute gfp.check to initiate the DRC.

    • The DRC runs on the server, after which results can be downloaded for local visualization.

  • Reviewing DRC Results

    • Review the errors locally; example results include one minimum width violation and five minimum space violations.

    • Errors can be browsed directly on your computer.

  • Using the API for Cloud-Based DRC Execution

    • The API uploads the GDS file to the cloud, performs the DRC, and downloads the results.

    • Ensure the GDSFactoryplus Python library and GDSFactory K-Layout extension are installed for full functionality.

  • Installing the GDSFactory Extension

    • If not installed, go to Tools > Packages in VS Code to download the GDSFactory extension.

Check connectivity#

  • Open the PDK component you want to check.

    • Identify connectivity errors, such as overlapping waveguides.

    • Overlapping waveguides may be obvious in simple layouts but harder to detect in complex layouts.

  • Running the Connectivity Check

    • Click the DRC button to start the connectivity check and press Check Connectivity

    • Results are displayed in the DRC Verification tab.

    • Errors are categorized for easier review:

      • Instance Overlaps: Displays all overlapping instances.

      • Orphan Ports: Highlights disconnected ports.

    • Highlight specific issues in the layout to inspect them in detail.

Contents