# Quickstart

pyTDGL solves a generalized time-depdendent Ginzburg-Landau (TDGL) equation for two-dimensional superconducting device with arbitrary geometry. At a high level, the TDGL model can be understood as a set of coupled partial differential equations (PDEs) describing the evolution of a complex field $$\psi(\mathbf{r}, t)$$ (the superconducting order parameter) and $$\mu(\mathbf{r}, t)$$ (the electric potential) in space and time.

The inputs to the model are:

1. Properties of the superconducting thin film: thickness $$d$$, Ginzburg-Landau coherence length $$\xi$$, and London penetration depth $$\lambda$$ (see tdgl.Layer).

2. The geometry of the device residing in the film, which can include holes (see tdgl.Polygon).

3. A time-independent applied magnetic vector potential $$\mathbf{A}_\mathrm{applied}(\mathbf{r})$$.

4. A set of applied bias currents which are sourced or sunk via a set of current terminals.

The outputs of the model are:

1. The complex order parameter $$\psi(\mathbf{r}, t)=|\psi|e^{i\theta}$$, where $$|\psi|^2=n_s$$ is the normalized superfluid density.

2. The electric scalar potential $$\mu(\mathbf{r}, t)$$, which arises from motion of vortices in the film.

3. The sheet current density in the device, $$\mathbf{K}(\mathbf{r}, t)=\mathbf{K}_s(\mathbf{r}, t)+\mathbf{K}_n(\mathbf{r}, t)$$, which is the sum of the sheet supercurrent density $$\mathbf{K}_s$$ and the sheet normal current density $$\mathbf{K}_n$$.

While the TDGL calculation is performed in dimensionless units, the inputs and outputs are specified in experimentalist-friendly physics units. The translation between the two is handled by the tdgl.Device class.

[1]:

# Automatically install tdgl from GitHub only if running in Google Colab
%pip install --quiet git+https://github.com/loganbvh/py-tdgl.git
!apt install ffmpeg

[2]:

%config InlineBackend.figure_formats = {"retina", "png"}

import os
import tempfile

from IPython.display import HTML, display
import h5py
import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["figure.figsize"] = (5, 4)

import tdgl
from tdgl.geometry import box, circle
from tdgl.visualization.animate import create_animation


Optionally, generate and display animations of the simulated dynamics.

[3]:

MAKE_ANIMATIONS = True


We will save the data to a temporary directory that will be removed at the end of the notebook.

[4]:

tempdir = tempfile.TemporaryDirectory()


Below we can create animations of the time-dependent simulation results. This is a helper function that animates a tdgl.Solution object so that it can be embedded in a notebook.

[5]:

def make_video_from_solution(
solution,
quantities=("order_parameter", "phase"),
fps=20,
figsize=(5, 4),
):
"""Generates an HTML5 video from a tdgl.Solution."""
with tdgl.non_gui_backend():
with h5py.File(solution.path, "r") as h5file:
anim = create_animation(
h5file,
quantities=quantities,
fps=fps,
figure_kwargs=dict(figsize=figsize),
)
video = anim.to_html5_video()
return HTML(video)