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.control.models.run(
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(segmentation_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.control.models.run(
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=(10, 10))
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()

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 conductance data (raw conductance, not a binary mask)
16
conductance_data = np.load("coulomb-diamond-detector-v1.npy")  # shape (n, n)
17
18
# Detect diamond structures directly from conductance data
19
result = client.control.models.run(
20
    model="coulomb-diamond-detector-v1",
21
    data=conductance_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
      14.587324142456055,
5
      63.440895080566406
6
    ],
7
    "right": [
8
      78.04255676269531,
9
      64.06403350830078
10
    ],
11
    "bottom": [
12
      63.72412872314453,
13
      32.74629592895508
14
    ],
15
    "top": [
16
      29.360164642333984,
17
      93.97402954101562
18
    ]
19
  },
20
  {
21
    "left": [
22
      78.05448150634766,
23
      63.42158508300781
24
    ],
25
    "right": [
26
      132.01417541503906,
27
      64.0471420288086
28
    ],
29
    "bottom": [
30
      118.5890121459961,
31
      42.59369659423828
32
    ],
33
    "top": [
34
      92.44355010986328,
35
      84.79678344726562
36
    ]
37
  }
38
]

1
from matplotlib import pyplot as plt
2
from mpl_toolkits.axes_grid1 import make_axes_locatable
3
4
fig, ax = plt.subplots(figsize=(10, 10))
5
6
ax.imshow(conductance_data, cmap="Blues", aspect="equal", origin="lower")
7
8
divider = make_axes_locatable(ax)
9
cax = divider.append_axes("right", size="4.5%", pad=0.35)
10
plt.colorbar(ax.images[0], cax=cax, label="Current (a.u.)")
11
12
for i, diamond in enumerate(diamond_vertices):
13
  x_coords = [
14
    diamond["top"][0],
15
    diamond["right"][0],
16
    diamond["bottom"][0],
17
    diamond["left"][0],
18
    diamond["top"][0],
19
  ]
20
  y_coords = [
21
    diamond["top"][1],
22
    diamond["right"][1],
23
    diamond["bottom"][1],
24
    diamond["left"][1],
25
    diamond["top"][1],
26
  ]
27
28
  if i == 0:
29
    ax.plot(
30
        x_coords,
31
        y_coords,
32
        "r--",
33
        linewidth=2,
34
        label="Predicted Coulomb Diamonds",
35
    )
36
  else:
37
    ax.plot(x_coords, y_coords, "r--", linewidth=2)
38
39
  center_x = (diamond["top"][0] + diamond["bottom"][0]) / 2
40
  center_y = (diamond["top"][1] + diamond["bottom"][1]) / 2
41
  ax.plot(center_x, center_y, "ro", markersize=6)
42
43
ax.set_xlabel("Gate Voltage 1 (a.u.)", fontsize=10)
44
ax.set_ylabel("Source Drain Bias Voltage (a.u.)", fontsize=10)
45
ax.tick_params(axis="both", labelsize=8)
46
ax.legend(fontsize=9)
47
48
plt.show()

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 conductance data (raw conductance, not a binary mask)
16
conductance_data = np.load("coulomb-diamond-detector-v2.npy")  # shape (n, n)
17
18
# Detect diamond structures directly from conductance data
19
result = client.control.models.run(
20
    model="coulomb-diamond-detector-v2",
21
    data=conductance_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
      73.8751220703125,
5
      68.38318634033203
6
    ],
7
    "top": [
8
      133.4462432861328,
9
      225.84364318847656
10
    ],
11
    "right": [
12
      164.4794464111328,
13
      65.03285217285156
14
    ],
15
    "bottom": [
16
      95.2346420288086,
17
      -95.74405670166016
18
    ]
19
  }
20
]

1
from matplotlib import pyplot as plt
2
from mpl_toolkits.axes_grid1 import make_axes_locatable
3
4
fig, ax = plt.subplots(figsize=(10, 10))
5
6
ax.imshow(conductance_data, cmap="Blues", aspect="equal", origin="lower")
7
8
divider = make_axes_locatable(ax)
9
cax = divider.append_axes("right", size="4.5%", pad=0.35)
10
plt.colorbar(ax.images[0], cax=cax, label="Current (a.u.)")
11
12
for i, diamond in enumerate(diamond_vertices):
13
  x_coords = [
14
    diamond["top"][0],
15
    diamond["right"][0],
16
    diamond["bottom"][0],
17
    diamond["left"][0],
18
    diamond["top"][0],
19
  ]
20
  y_coords = [
21
    diamond["top"][1],
22
    diamond["right"][1],
23
    diamond["bottom"][1],
24
    diamond["left"][1],
25
    diamond["top"][1],
26
  ]
27
28
  if i == 0:
29
    ax.plot(
30
        x_coords,
31
        y_coords,
32
        "r--",
33
        linewidth=2,
34
        label="Predicted Coulomb Diamonds",
35
    )
36
  else:
37
    ax.plot(x_coords, y_coords, "r--", linewidth=2)
38
39
  center_x = (diamond["top"][0] + diamond["bottom"][0]) / 2
40
  center_y = (diamond["top"][1] + diamond["bottom"][1]) / 2
41
  ax.plot(center_x, center_y, "ro", markersize=6)
42
43
ax.set_xlabel("Gate Voltage 1 (a.u.)", fontsize=10)
44
ax.set_ylabel("Source Drain Bias Voltage (a.u.)", fontsize=10)
45
ax.tick_params(axis="both", labelsize=8)
46
ax.legend(fontsize=9)
47
48
plt.show()