Using Coulomb Diamond Models

1
from dotenv import load_dotenv
2
import os
3
from conductorquantum import ConductorQuantum
4
5
# Load API key from .env file
6
load_dotenv()
7
TOKEN = os.getenv("CONDUCTOR_API_KEY")
8
9
# Initialize client
10
client = ConductorQuantum(token=TOKEN)

1
from conductorquantum import ConductorQuantum
2
3
# Initialize client with API key
4
client = ConductorQuantum(token="YOUR_API_KEY")

1
from dotenv import load_dotenv
2
import os
3
import numpy as np
4
from conductorquantum import ConductorQuantum
5
6
7
# Load API key from .env file
8
load_dotenv()
9
TOKEN = os.getenv("CONDUCTOR_API_KEY")
10
11
# Initialize client
12
client = ConductorQuantum(token=TOKEN)
13
14
# Load Coulomb Diamond Conductance Grid data
15
data = np.load("coulomb-diamond-segmenter-v0.npy")  # shape (N, M)
16
17
# Segment the Coulomb Diamond Conductance Grid
18
result = client.models.execute(
19
    model="coulomb-diamond-segmenter-v0",
20
    data=data
21
)
22
23
# Access the binary segmentation mask result
24
segmentation_mask = result.output["segmentation"]
25
segmentation_mask_array = np.array(segmentation_mask)
26
27
# Get non-zero indices: assume shape is (1, H, W)
28
nonzero_coords = np.argwhere(binary_mask_array)
29
coords_2d = [tuple(coord[1:]) for coord in nonzero_coords]
30
31
# Format output
32
summary = ", ".join(str(t) for t in coords_2d[:10])
33
if len(coords_2d) > 10:
34
    summary += f", ... (total {len(coords_2d)} non-zero pixels)"
35
print(f"Coulomb Diamond regions at: {summary}")

1
Coulomb Diamond regions at: (0, 52), (0, 53), (0, 54), (0, 55), (0, 56), (0, 57), (0, 58), (0, 59), (0, 60), (0, 61), ... (total 47046 non-zero pixels)

1
from dotenv import load_dotenv
2
import os
3
import json
4
import numpy as np
5
from conductorquantum import ConductorQuantum
6
7
8
# Load API key from .env file
9
load_dotenv()
10
TOKEN = os.getenv("CONDUCTOR_API_KEY")
11
12
# Initialize client
13
client = ConductorQuantum(token=TOKEN)
14
15
# Load Coulomb Diamond Detection data 
16
detection_data = np.load("coulomb-diamond-detector-v0.npy") # shape (n, m)
17
18
# Detect diamond structures via the Coulomb Diamond Detector
19
result = client.models.execute(
20
    model="coulomb-diamond-detector-v0",
21
    data=detection_data
22
)
23
24
# Access the diamond vertices result
25
diamond_vertices = result.output["diamond_vertices"]
26
print(f"Diamond Vertices: {json.dumps(diamond_vertices, indent=2)}")

1
Diamond Vertices: [
2
  {
3
    "left": [
4
      127.83405292034149,
5
      128.76852416992188
6
    ],
7
    "right": [
8
      193.11397564411163,
9
      128.75509643554688
10
    ],
11
    "bottom": [
12
      131.53489315509796,
13
      -137.0048828125
14
    ],
15
    "top": [
16
      189.41313540935516,
17
      394.52850341796875
18
    ]
19
  }
20
]

1
from matplotlib import pyplot as plt
2
from matplotlib.colors import ListedColormap
3
4
fig, ax = plt.subplots(figsize=(5, 5))
5
6
colors = ["white", "#1f4e79"]
7
cmap = ListedColormap(colors)
8
9
ax.imshow(detection_data, cmap=cmap, aspect="auto", origin="lower")
10
11
for i, diamond in enumerate(diamond_vertices):
12
  x_coords = [
13
    diamond["top"][0],
14
    diamond["right"][0],
15
    diamond["bottom"][0],
16
    diamond["left"][0],
17
    diamond["top"][0],
18
  ]
19
  y_coords = [
20
    diamond["top"][1],
21
    diamond["right"][1],
22
    diamond["bottom"][1],
23
    diamond["left"][1],
24
    diamond["top"][1],
25
  ]
26
27
  if i == 0:
28
    ax.plot(
29
        x_coords,
30
        y_coords,
31
        "r--",
32
        linewidth=2,
33
        label="Predicted Coulomb Diamonds",
34
    )
35
  else:
36
    ax.plot(x_coords, y_coords, "r--", linewidth=2)
37
38
  center_x = (diamond["top"][0] + diamond["bottom"][0]) / 2
39
  center_y = (diamond["top"][1] + diamond["bottom"][1]) / 2
40
  ax.plot(center_x, center_y, "ro", markersize=6)
41
42
ax.fill_between([0, 0], [0, 0], color="#1f4e79", label="Coulomb Diamond Region")
43
ax.set_xlabel("Gate Voltage 1 (indices)", fontsize=12)
44
ax.set_ylabel("Gate Voltage 2 (indices)", fontsize=12)
45
46
plt.show()