How to implement a refocussing function into Qcodes

[Rueschi1]

Hello everyone,

I’m just getting started with QCoDeS, so apologies if this is a basic question.

We’re working with an optical setup where we need to run long measurements at a fixed position. To keep the sample in focus, we use a piezo connected to the sample stage. The piezo is driven via an analog output of a DAQ card, and the same DAQ is used to read out the electrical signal from an APD.

What I’m trying to do is implement a function that optimizes the stage (piezo) position based on the detected counts. I’d like to trigger this optimization either:

• periodically (after a certain amount of time), or
• whenever the counts cross a threshold.

What’s the best way to integrate this kind of “autofocus” step into a simple measurement loop like the one below?

with context_meas.run() as datasaver:
    for set_v in np.linspace(0, 25, 10):
        dac.ch1.set(set_v)
        get_v = dmm.v1.get()
        datasaver.add_result((dac.ch1, set_v), (dmm.v1, get_v))

    dataset = datasaver.dataset

Hope the question is clear—thanks a lot for any advice!

[astafan8]

What an interesting quesion! thank you!

this really depends on how you identify the moment when this refocus is needed. So if for example you want to do it every 10 points of the sweep, then just add a condition for that inside the for-loop:

for idx, set_v in enumerate(np.linspace(0,25,100):
    if idx % 10 == 0:
        do_auto_focus()
    ....

If you have a morecomplicated scenario, you can still implement it - that's the power of the measurement context manager (as compared to e.g. dond function) that it's plain python, so feel free to do what you need to do, and at some point just call add_result when the time is right to store the data.

[Rueschi1]

Thank you for the quick reply! If it's fine for you I will try to implement it today and come back with the actual example code to check that how I am using the instrument class for the measurement loop and the auto_focus makes sense.

[Rueschi1]

Alright it took longer then expected but now I think I understand better what my actual question is:

Given that I am inside the main experiment which is effectively creating a 2D map of the laser position and intensity and saving it into the main .db file. I now want to do a this auto_focus function each x lines of the 2D plot.

For now I wrote this as a simple python function but I am wondering if there is a good way to now also save these runs to the .db file without cluttering it too much with these "non important" measurements. Is it recommended to for example swap the database during the measurement to have one dedicated to the auto focus data?

"
def focus_optical_z(
daq,
center: float = 0.0,
width: float = 0.5,
n_points: int = 51,
dwell_s: float = 0.01,
verbose: bool = True,
) -> Tuple[np.ndarray, np.ndarray, Optional[Dict[str, float]]]:
"""
Sweep ao2, measure count_rate, fit Gaussian, and set ao2 to best focus.

Args:
    daq: An instance of DAQ_NI6353 (or compatible) with parameters
         `ao2` and `count_rate`.
    center: Center voltage of the sweep.
    width: Half-width of the sweep around center. The sweep will run from
           (center - width) to (center + width).
    n_points: Number of voltage points in the sweep.
    dwell_s: Optional dwell time at each point before measuring.
    verbose: If True, print progress and fit info.

Returns:
    voltages: 1D array of voltages used in the sweep.
    counts:   1D array of measured count rates.
    fit_params: dict with keys ['A', 'x0', 'sigma', 'offset'] if Gaussian
                fit succeeded and SciPy is available, otherwise None.
"""
v_min = center - width
v_max = center + width

voltages = np.linspace(v_min, v_max, n_points)
counts = np.zeros_like(voltages, dtype=float)

if verbose:
    print(f"Sweeping ao2 from {v_min} V to {v_max} V in {n_points} steps...")

for i, v in enumerate(voltages):
    daq.ao2(v)
    if dwell_s > 0:
        time.sleep(dwell_s)
    cr = daq.count_rate()
    counts[i] = cr
    if verbose:
        print(f"{i + 1:3d}/{n_points}: V = {v:.4f} V, count_rate = {cr:.1f} cps")

fit_params: Optional[Dict[str, float]] = None

if _HAS_SCIPY and n_points >= 4 and np.isfinite(counts).all():
    # Initial guesses: amplitude, center, width, offset
    A0 = float(counts.max() - counts.min())
    x0 = float(voltages[np.argmax(counts)])
    sigma0 = float((v_max - v_min) / 6.0) if v_max > v_min else 0.1
    offset0 = float(counts.min())
    p0 = (A0, x0, sigma0, offset0)

    try:
        popt, _ = curve_fit(gaussian, voltages, counts, p0=p0)
        A, x0_fit, sigma, offset = map(float, popt)
        fit_params = {"A": A, "x0": x0_fit, "sigma": sigma, "offset": offset}
        if verbose:
            print(f"Gaussian fit: x0 = {x0_fit:.5f} V, sigma = {sigma:.5f} V")
        best_v = x0_fit
    except Exception as e:  # pragma: no cover - fit failures are rare and hardware-specific
        if verbose:
            print(f"Gaussian fit failed ({e}); falling back to max(counts).")
        best_v = float(voltages[np.argmax(counts)])
else:
    if verbose and not _HAS_SCIPY:
        print("SciPy not available; using simple max(counts) for focus.")
    best_v = float(voltages[np.argmax(counts)])

# Move to best focus voltage
daq.ao2(best_v)
if verbose:
    print(f"Setting ao2 to best focus: {best_v:.5f} V")

return voltages, counts, fit_params

"