qtt package

Quantum Technology Toolbox

The QTT package contains functionality for the tuning and calibration of spin-qubits. The package is divided into subpackages:

Measurements: functionality to perform measurements on devices

Algorithms: functionality to analyse measurements

Simulation: contains simulations of quantum dot systems

Tools: misc tools

Gui: Several gui element for visualization of data

Instrument drivers: contains QCoDeS drivers for various instruments

For more information see https://github.com/qutech-delft/qtt

qtt.abort_measurements(value=None): Return True if the currently running measurement should be aborted

qtt.check_version(version, module=<module 'qcodes' from '/home/docs/checkouts/readthedocs.org/user_builds/qtt/envs/latest/lib/python3.8/site-packages/qcodes/__init__.py'>, optional=False, install_message=None)[source]: Check whether a module has the correct version

qtt.liveValue(var='qtt_live_value1'): Return live control value retrieved from redis server and convert to string

qtt.liveValueSet(value, var='qtt_live_value1'): Set live control value on redis server

qtt.reset_abort(value=0)[source]: reset qtt_abort_running_measurement

qtt.set_location_name(name, verbose=1)[source]

Subpackages

Submodules

qtt.data module

Utilities to work with data and datasets

qtt.data.add_comment(txt, dataset=None, verbose=0)[source]

Add a comment to a DataSet

Parameters:

comment (str) – comment to be added to the DataSet metadata
dataset (None or DataSet) – DataSet to add the comments to

qtt.data.compare_dataset_metadata(dataset1, dataset2, metakey='allgatevalues', verbose=1)[source]

Compare metadata from two different datasets.

Outputs the differences in metadata from dataset1 to dataset2. For now, only comparisons for the key ‘allgatevalues’ has been implemented.

Parameters:

dataset1 (DataSet) – first dataset to compare
dataset2 (DataSet) – second dataset to compare
metakey (str) – key in the DataSet metadata to compare

qtt.data.dataset1Ddata(alldata)[source]

Parse a dataset into the x and y scan values

Returns:: x (array) y (array)

qtt.data.dataset1Dmetadata(alldata, arrayname=None, verbose=0)[source]

Extract metadata from a 1D scan

Returns:: x1,x2 g0 (string): step gate vstep (array): step values istep (float) arrayname (string): identifier of the main array
Return type:: extent (list)

qtt.data.dataset2Dmetadata(alldata, arrayname=None, verbose=0)[source]

Extract metadata from a 2D scan

Returns:: x1,x2,y1,y2 g0 (str): step gate (array_id) g1 (str): sweep gate (array_id) vstep (array): step values vsweep (array): sweep values arrayname (string): identifier of the main array
Return type:: extent (list)

qtt.data.dataset2image(dataset, arrayname=None, unitsperpixel=None, mode='pixel')[source]

Extract image from a dataset

Parameters:

dataset (DataSet) – structure with 2D data
arrayname (None or str) – nafme of array to select
mode (str) – if value is ‘pixel’ then the image is converted so that it is in conventional coordinates, e.g. the step values (vertical axis) go from low to high (bottom to top).

Returns:

im (numpy array) tr (image_transform object)

qtt.data.dataset2image2(dataset, arrayname=None)[source]

Extract image from dataset

Parameters:: dataset (DataSet) – measured data
Returns:: raw image impixel (array): image in pixel coordinates tr (image_transform object): transformation object
Return type:: imraw (array)

qtt.dataset_processing module

qtt.dataset_processing.average_dataset(dataset: DataSet, axis: str | int = 'vertical') → DataSet[source]

Calculate the mean signal of a 2D dataset over the specified axis

Parameters:

dataset – DataSet to be processed
axis – Specification of the axis

Returns:

Dataset with averaged signal

qtt.dataset_processing.average_multirow_dataset(dataset: DataSet, number_of_repetitions: int, new_values=None, parameter_name: str = 'signal', output_parameter_name: str = 'signal') → DataSet[source]

Calculate the averaged signal from a 2D dataset with repeated rows

Parameters:

dataset – Dataset containing the data to be averaged
number_of_repetitions – Number of rows over which to average
new_values – Optional new values for the averaged axis
parameter_name – Name of data array to process
output_parameter_name – Name of output array

Returns:

Averaged dataset

qtt.dataset_processing.dataset_dimension(dataset: DataSet) → int[source]: Return dimension of DataSet

qtt.dataset_processing.process_dataarray(dataset: DataSet, input_array_name: str, output_array_name: str | None, processing_function: Callable, label: str | None = None, unit: str | None = None) → DataSet[source]

Apply a function to a DataArray in a DataSet

Parameters:

dataset – Input dataset containing the data array
input_array_name – Name of the data array to be processed
output_array_nane – Name of the output array or None to operate in place
processing_function – Method to apply to the data array
label – Label for the output array
unit – Unit for the output array

qtt.dataset_processing.resample_dataset(dataset: DataSet, sample_rate: Tuple[int], copy_metadata: bool = False, output_parameter_name: str | None = None) → DataSet[source]

Given a dataset resample the measurement array

Parameters:

dataset – Dataset to be slice
sample_rate – Tuple with for each axis the sample rate. Must be a postive integer
copy_metadata – If True then copy the metadata of the input dataset
output_parameter_name – Name of the output array

Returns:

Dataset with sliced data

qtt.dataset_processing.slice_dataset(dataset: DataSet, window: Sequence[float], axis: int = 0, verbose: int = 0, copy_metadata: bool = False, output_parameter_name=None) → DataSet[source]

Given a dataset and a window for the horizontal axis return the dataset with selected window

Parameters:

dataset – Dataset to be slice
window – Specification of the window to be selected
axis – Axis used for slicing
verbose – Verbosity level
copy_metadata – If True then copy the metadata of the input dataset
output_parameter_name – Name of the output array

Returns:

Dataset with sliced data

qtt.exceptions module

exception qtt.exceptions.CalibrationException[source]

Bases: Exception

Exception thrown for a bad calibration

exception qtt.exceptions.MissingOptionalPackageWarning[source]

Bases: UserWarning, ValueError

An optional package is missing

exception qtt.exceptions.PackageVersionWarning[source]

Bases: UserWarning

A package has the incorrect version

qtt.pgeometry module

pgeometry

A collection of usefull functions.

For additional options also see numpy and matplotlib.

platform:: Unix, Windows

Additions:: Copyright 2012-2016 TNO
Original code:: Copyright 2011 Pieter Eendebak <pieter.eendebak@gmail.com>

@author: eendebakpt

qtt.pgeometry.RBE2euler(Rbe)[source]: Convert rotation matrix to Euler angles

qtt.pgeometry.T2opencv(T: ndarray) → Tuple[ndarray, ndarray][source]

Convert transformation to OpenCV rvec, tvec pair

Example

>>> rvec, tvec = T2opencv(np.eye(4))

qtt.pgeometry.addfigurecopy(fig=None)[source]

Add callback to figure window

By pressing the ‘c’ key figure is copied to the clipboard

qtt.pgeometry.angleDiff(x, y)[source]

Return difference between two angles in radians modulo 2* pi

>>> d=angleDiff( 0.01, np.pi+0.02)
>>> d=angleDiff( 0.01, 2*np.pi+0.02)
>>> d=angleDiff(np.array([0,0,0]), np.array([2,3,4]))

qtt.pgeometry.angleDiffOri(x, y)[source]

Return difference between two angles in radians modulo pi

>>> d=angleDiff( 0.01, np.pi+0.02)
>>> d=angleDiff( 0.01, 2*np.pi+0.02)

qtt.pgeometry.auto_canny(image: ndarray, sigma: float = 0.33) → ndarray[source]

Canny edge detection with automatic parameter detection

>>> imc=auto_canny(np.zeros( (200,300)).astype(np.uint8))

Parameters:: image (array) – input image
Returns:: edged – detected edges
Return type:: array

Code from: http://www.pyimagesearch.com/2015/04/06/zero-parameter-automatic-canny-edge-detection-with-python-and-opencv/

qtt.pgeometry.blur_measure(im, verbose=0)[source]

Calculate bluriness for an image

Parameters:: im (array) – input image

qtt.pgeometry.breakLoop(wk=None, dt=0.001, verbose=0)[source]: Break a loop using OpenCV image feedback

qtt.pgeometry.cd(dd='')[source]: Change current working directory

qtt.pgeometry.cfigure(*args, **kwargs)[source]

Create Matplotlib figure with copy to clipboard functionality

By pressing the ‘c’ key figure is copied to the clipboard

qtt.pgeometry.checkmodule(module_name, verbose=1)[source]

Return location of module based on module name

Parameters:: module_name (str) – name of module to inspect

Returns: obj: module specification

qtt.pgeometry.choose(n, k)[source]

Binomial coefficients Return the n!/((n-k)!k!)

Parameters:

Integer (k --) –
Integer –

Returns:

The bionomial coefficient n choose k

Example

>>> choose(6,2)
15

qtt.pgeometry.circular_mean(weights, angles)[source]: Calculate circular mean of a set of 2D vectors

qtt.pgeometry.decomposeProjectiveTransformation(H, verbose=0)[source]

Decompose projective transformation H is decomposed as H = Hs*Ha*Hp with

Hs = [sR t]
[0 1]

Ha = [K 0]
[0 1]

Hp = [I 0]
[v’ eta]

If H is 3-dimensional, then R = [ cos(phi) -sin(phi); sin(phi) cos(phi)];

For more information see “Multiple View Geometry”, paragraph 1.4.6.

>>> Ha, Hs, Hp, rest = decomposeProjectiveTransformation( np.eye(3) )

qtt.pgeometry.dehom(x: ndarray) → ndarray[source]: Convert homogeneous points to affine coordinates

qtt.pgeometry.detect_local_minima(arr, thr=None)[source]

Takes an array and detects the troughs using the local maximum filter. Returns a boolean mask of the troughs (i.e. 1 when the pixel’s value is the neighborhood maximum, 0 otherwise)

Parameters:: arr (array) – input array

qtt.pgeometry.dir2R(d, a=None)[source]

Convert direction to rotation matrix

Note: numerically not stable near singular points!

Parameters:

d (numpy array of size 3) – direction to rotation to a
a (numpy array of size 3) – target direction

Returns:

matrix R such that R*a = d

Return type:

R (3x3 numpy array)

Example:

>>> d = np.array([0, 1, 0]); a = np.array([0, -1, 0])
>>> R = dir2R(d, a)

Pieter Eendebak <pieter.eendebak@tno.nl>

qtt.pgeometry.directionMean(vec)[source]

Calculate the mean of a set of directions

The initial direction is determined using the oriented direction. Then a non-linear optimization is done.

Parameters:: vec – List of directions

Returns: Angle of mean of directions

>>> vv=np.array( [[1,0],[1,0.1], [-1,.1]])
>>> a=directionMean(vv)

qtt.pgeometry.enlargelims(factor=1.05)[source]

Enlarge the limits of a plot

Parameters:: factor (float or list of float) – Factor to expand the limits of the current plot

Example

>>> enlargelims(1.1)

qtt.pgeometry.euler2RBE(theta)[source]

Convert Euler angles to rotation matrix

Example

>>> np.set_printoptions(precision=4, suppress=True)
>>> euler2RBE( [0,0,np.pi/2] )
array([[ 0., -1.,  0.],
       [ 1.,  0.,  0.],
       [-0.,  0.,  1.]])

qtt.pgeometry.findImageHandle(fig, verbose=0, otype=<class 'matplotlib.image.AxesImage'>)[source]: Search for specific type of object in Matplotlib figure

qtt.pgeometry.finddirectories(p, patt)[source]: Get a list of files

qtt.pgeometry.findfiles(p, patt, recursive=False)[source]: Get a list of files

qtt.pgeometry.findfilesR(p, patt, show_progress=False)[source]

Get a list of files (recursive)

Parameters:

p (string) – directory
patt (string) – pattern to match
show_progress (bool) –

Returns:

lst (list of str)

qtt.pgeometry.fitPlane(X: ndarray) → ndarray[source]

Determine plane going through a set of points

Parameters:: X (array) – aray of size Nxk. Points in affine coordinates
Returns:: fitted plane in homogeneous coordinates
Return type:: array

Example

>>> X=np.array([[1,0,0 ], [0,1,0], [1,1,0], [2,2,0]])
>>> t=fitPlane(X)

class qtt.pgeometry.fps_t(nn: int = 40)[source]

Bases: object

addtime(t: float | None = None, x: float = 0)[source]

Add a timestamp to the object

Parameters:

t – Timestamp. If None, use time.perf_counter
x – Optional value to store with the timestamp

framerate() → float[source]: Return the current framerate

iim() → float[source]: Return index modulo number of elements

loop(s: str = '')[source]: Helper function

show()[source]: Print the current framerate

showloop(dt: float = 2, s: str = '')[source]

Print current framerate in a loop

The print statement is only executed once every dt seconds

value() → float[source]: Return mean of current values

qtt.pgeometry.frame2T(f)[source]: Convert frame into 4x4 transformation matrix

qtt.pgeometry.freezeclass(cls)[source]

Decorator to freeze a class

This means that no attributes can be added to the class after instantiation.

qtt.pgeometry.fullpath(*args)[source]: Return full path from a list

qtt.pgeometry.gaborFilter(ksize, sigma, theta, Lambda=1, psi=0, gamma=1, cut=None)[source]

Create a Gabor filter of specified size

Parameters:

ksize (integer) – kernel size in pixels
sigma (float) – parameters of Gabor function
theta (float) – parameters of Gabor function
Lambda (float) – parameters of Gabor function
psi (float) – parameters of Gabor function
cut (boolean) – if True cut off the angular component after specified distance (in radians)

Returns:

g – constructed kernel

Return type:

array

Example

>>> g = gaborFilter(ksize=15, sigma=2,theta=2,Lambda=1, gamma=1)

qtt.pgeometry.getWindowRectangle()[source]: Return current matplotlib window rectangle

qtt.pgeometry.ginput(n=1, drawmode='', **kwargs)[source]

Select points from figure

Press middle mouse button to stop selection

Parameters:

select (n - number of points to) –
points (drawmode - style to plot selected) –
kwargs – arguments passed to plot function

qtt.pgeometry.histogram(x, nbins=30, fig=1)[source]

Return histogram of data

>>> _=histogram(np.random.rand(1,100))

qtt.pgeometry.hom(x: ndarray) → ndarray[source]

Create affine to homogeneous coordinates

Parameters:: x (kxN array) – affine coordinates
Returns:: homogeneous coordinates
Return type:: h ( (k+1xN) array)

qtt.pgeometry.imshowz(im, *args, **kwargs)[source]: Show image with interactive z-values

qtt.pgeometry.intersect2lines(l1, l2)[source]

Calculate intersection between 2 lines

Parameters:

l1 (array) – first line in homogeneous format
l2 (array) – first line in homogeneous format

Returns:

intersection in homogeneous format. To convert to affine coordinates use dehom

Return type:

array

qtt.pgeometry.list_objects(objectype=None, objectclassname='__123', verbose=1)[source]

List all objects in memory of a specific type or with a specific class name

Parameters:

objectype (None or class) –
objectclassname (str) –

Returns:

list of objects found

Return type:

ll (list)

qtt.pgeometry.load(pkl_file)[source]: Load objects from file

qtt.pgeometry.logistic(x, x0=0, alpha=1)[source]

Simple logistic function

Parameters:: x (float or array) –

>>> t=np.arange(0,600,1.)
>>> _ = plt.plot(t, logistic(t, 300, alpha=1./100),'.b')

qtt.pgeometry.memUsage()[source]

Prints the memory usage in MB

Uses the resource module

qtt.pgeometry.memory() → float[source]

Return the memory usage in MB

Returns:: Memory usage in MB

qtt.pgeometry.minAlg_5p4(A: ndarray) → ndarray[source]

Algebraic minimization function

Function computes the vector x that minimizes ||Ax|| subject to the condition ||x||=1. Implementation of Hartley and Zisserman A5.4 on p593 (2nd Ed)

Usage: [x,V] = minAlg_5p4(A) :param A: The constraint matrix, ||Ax|| to be minimized :type A: numpy array

Returns:

x - The vector that minimizes ||Ax|| subject to the: condition ||x||=1

qtt.pgeometry.mkdirc(d: str)[source]: Similar to mkdir, but no warnings if the directory already exists

qtt.pgeometry.modulepath(m)[source]

Return path for module

Parameters:: m (str or module) – module to return path
Returns:: path of module
Return type:: str

qtt.pgeometry.monitorSizes(verbose: int = 0) → List[List[int]][source]

Return monitor sizes

Parameters:: verbose – Verbosity level
Returns:: List with for each screen a list x, y, width, height

qtt.pgeometry.mpl2clipboard(event=None, verbose: int = 0, fig: int | Figure | None = None)[source]

Copy current Matplotlib figure to clipboard

Parameters:

event – Unused argument
verbose – Verbosity level
fig – Figure handle. If None, select the current figure

qtt.pgeometry.null(a, rtol=1e-05)[source]: Calculate null space of a matrix

qtt.pgeometry.opencv2T(rvec, tvec)[source]: Convert OpenCV pose to homogenous transform

qtt.pgeometry.opencv2TX(rvecs, tvecs)[source]: Convert OpenCV pose to homogenous transform

qtt.pgeometry.opencv_draw_points(bgr, imgpts, drawlabel=True, radius=3, color=(255, 0, 0), thickness=-1, copyimage=True)[source]

Draw points on image with opencv

Parameters:

bgr (numpy array) – image to draw points into
impts (array) – locations of points to plot

qtt.pgeometry.opencvpose2attpos(rvecs, tvecs)[source]

qtt.pgeometry.orthogonal_proj(zfront, zback)[source]: see http://stackoverflow.com/questions/23840756/how-to-disable-perspective-in-mplot3d

qtt.pgeometry.otsu(im, fig=None)[source]

Calculate threshold on data using Otsu’s method

Parameters:

im (array) – data to be processed
fig (number, optional) – If set to a number show results in a histogram

Returns:

thr – The threshold value

Return type:

float

Examples

>>> thr = otsu(np.random.rand( 2000), fig=100)

qtt.pgeometry.package_versions(verbose: int = 1)[source]: Report package versions installed

qtt.pgeometry.pcolormesh_centre(x, y, im, *args, **kwargs)[source]: Wrapper for pcolormesh to plot pixel centres at data points

qtt.pgeometry.pg_rotation2H(R)[source]: Convert rotation matrix to homogenous transform matrix

qtt.pgeometry.pg_rotx(phi: float) → ndarray[source]: Create rotation around the x-axis with specified angle

qtt.pgeometry.pg_scaling(scale: float | ndarray, cc: ndarray | None = None) → ndarray[source]

Create scale transformation with specified centre

Parameters:

scale – Scaling vector
cc – Centre for the scale transformation. If None, then take the origin

Returns:

Scale transformation

Example

>>> pg_scaling( [1.,2])
array([[ 1.,  0.,  0.],
       [ 0.,  2.,  0.],
       [ 0.,  0.,  1.]])

qtt.pgeometry.pg_transl2H(tr)[source]

Convert translation to homogeneous transform matrix

>>> pg_transl2H( [1,2])
array([[ 1.,  0.,  1.],
        [ 0.,  1.,  2.],
        [ 0.,  0.,  1.]])

qtt.pgeometry.plot2Dline(line, *args, **kwargs)[source]

Plot a 2D line in a matplotlib figure

Parameters:: line (3x1 array) – line to plot

>>> plot2Dline([-1,1,0], 'b')

class qtt.pgeometry.plotCallback(func=None, xdata=None, ydata=None, scale=[1, 1], verbose=0)[source]

Bases: object

connect(fig)[source]

qtt.pgeometry.plotCostFunction(fun, x0, fig=None, marker='.', scale=1, c=None)[source]

Plot a cost function on specified data points

Example with variation of Booth’s function:

>>> fun = lambda x: 2*(x[0]+2*x[1]-7)**2 + (2*x[0]+x[1]-5)**2
>>> plotCostFunction(fun, np.array([1,3]), fig=100, marker='-')

qtt.pgeometry.plotLabels(xx, *args, **kwargs)[source]

Plot labels next to points

Parameters:

xx (2xN array) – points to plot
*kwargs – arguments past to plotting function

Example: >>> xx=np.random.rand(2, 10) >>> fig=plt.figure(10); plt.clf() >>> _ = plotPoints(xx, ‘.b’); _ = plotLabels(xx)

qtt.pgeometry.plotPoints(xx, *args, **kwargs)[source]

Plot 2D or 3D points

Parameters:

xx (array) – array of points to plot
*args – arguments passed to the plot function of matplotlib
**kwargs – arguments passed to the plot function of matplotlib

Example: >>> plotPoints(np.random.rand(2,10), ‘.-b’)

qtt.pgeometry.plotPoints3D(xx, *args, **kwargs)[source]

Plot 3D points

Parameters:: xx (3xN array) – the 3D data points

Example

>> ax=plotPoints3D(np.random.rand(3, 1) ,’.r’, markersize=10, fig=12)

qtt.pgeometry.point_in_polygon(pt, pp)[source]

Return True if point is in polygon

Parameters:

pt (1x2 array) – point
pp (Nx2 array) – polygon

Returns:

1.0 if point is inside 1.0, otherwise -1.0

Return type:

r (float)

qtt.pgeometry.points_in_polygon(pts, pp)[source]

Return all points contained in a polygon

Parameters:

pt (Nx2 array) – points
pp (Nxk array) – polygon

Returns:

rr (bool array)

qtt.pgeometry.polyarea(p: List[List[float]] | ndarray) → float[source]

Return signed area of polygon

Parameters:: p (Nx2 numpy array or list of vertices) – vertices of polygon
Returns:: area – area of polygon
Return type:: float

>>> polyarea( [ [0,0], [1,0], [1,1], [0,2]] )
1.5

qtt.pgeometry.polyintersect(x1: ndarray, x2: ndarray) → ndarray[source]

Calculate intersection of two polygons

Parameters:

x1 – First polygon. Shape is (N, 2) with N the number of vertices
x2 – Second polygon

Returns:

Intersection of both polygons

Raises:

ValueError if the intersection consists of multiple polygons –

>>> x1=np.array([(0, 0), (1, 1), (1, 0)] )
>>> x2=np.array([(1, 0), (1.5, 1.5), (.5, 0.5)])
>>> x=polyintersect(x1, x2)
>>> _=plt.figure(10); plt.clf()
>>> plotPoints(x1.T, '.:r' )
>>> plotPoints(x2.T, '.:b' )
>>> plotPoints(x.T, '.-g' , linewidth=2)

qtt.pgeometry.projectiveTransformation(H: ndarray, x: ndarray) → ndarray[source]

Apply a projective transformation to a kxN array

>>> y = projectiveTransformation( np.eye(3), np.random.rand( 2, 10 ))

qtt.pgeometry.qtModules(verbose=0)[source]: Return list of Qt modules loaded

qtt.pgeometry.raiseWindow(fig)[source]: Raise a matplotlib window to to front

qtt.pgeometry.region2poly(rr)[source]: Convert a region (bounding box xxyy) to polygon

qtt.pgeometry.robustCost(x: ndarray, thr: float | str | None, method: str = 'L1') → ndarray | List[str][source]

Robust cost function

Parameters:

x – data to be transformed
thr – threshold. If None then the input x is returned unmodified. If ‘auto’ then use automatic detection (at 95th percentile)
method – method to be used. use ‘show’ to show the options

Returns:

Cost for each element in the input array

Example

>>> robustCost([2, 3, 4], thr=2.5)
array([ 2. ,  2.5,  2.5])
>>> robustCost(2, thr=1)
1
>>> methods=robustCost(np.arange(-5,5,.2), thr=2, method='show')

qtt.pgeometry.rot2D(phi: float) → ndarray[source]

Return 2x2 rotation matrix from angle

Parameters:: phi (float) – Angle in radians
Returns:: R – The 2x2 rotation matrix
Return type:: array

Examples

>>> R = rot2D(np.pi)

qtt.pgeometry.rottra2mat(rot, tra)[source]: create 4x4 matrix from 3x3 rot and 1x3 tra

qtt.pgeometry.runcmd(cmd, verbose=0)[source]: Run command and return output

qtt.pgeometry.save(pkl_file, *args)[source]

Save objects to file

Parameters:

pkl_file (string) – filename
*args (anything) – Python objects to save

qtt.pgeometry.scaleImage(image: ndarray, display_min: float | None = None, display_max: float | None = None) → ndarray[source]

Scale any image into uint8 range

Parameters:

image – input image
display_min – value to map to min output range
display_max – value to map to max output range

Returns:

The scaled image

Example

>>> im=scaleImage(255*np.random.rand( 30,40), 40, 100)

Code modified from: https://stackoverflow.com/questions/14464449/using-numpy-to-efficiently-convert-16-bit-image-data-to-8-bit-for-display-with?noredirect=1&lq=1

qtt.pgeometry.setFontSizes(labelsize=20, fsize=17, titlesize=None, ax=None)[source]: Update font sizes for a matplotlib plot

Position the current Matplotlib figure at the specified position

Parameters:

x – position in format (x,y,w,h)
y – y position, width, height
w – y position, width, height
h – y position, width, height
fig (None or int) – specification of figure window. Use None for the current active window

Usage: setWindowRectangle([x, y, w, h]) or setWindowRectangle(x, y, w, h)

qtt.pgeometry.setregion(im, subim, pos, mask=None, clip=False)[source]

Set region in Numpy image

Parameters:

im (Numpy array) – image to fill region in
subim (Numpy array) – subimage
pos (array) – position to place image
array) (mask (None or) –
(bool) (clip) –

class qtt.pgeometry.signalTest[source]

Bases: QObject

Helper function for Qt signals

go()[source]

s

qtt.pgeometry.signedmin(val, w)[source]

Signed minimum value function

>>> signedmin(-3, 5)
-3
>>> signedmin(-10, 5)
-5

qtt.pgeometry.signedsqrt(val)[source]

Signed square root function

>>> signedsqrt([-4.,4,0])
array([-2.,  2.,  0.])
>>> signedmin(-10, 5)
-5

qtt.pgeometry.slotTest(txt)[source]: Helper function for Qt slots

qtt.pgeometry.smoothstep(x, x0=0, alpha=1)[source]

Smooth step function

>>> t=np.arange(0,600,1.)
>>> _ = plt.plot(t, smoothstep(t, 300, alpha=1./100),'.b')

qtt.pgeometry.static_var(varname: str, value: Any)[source]

Helper function to create a static variable on a method

Parameters:

varname – Variable to create
value – Initial value to set

qtt.pgeometry.tilefigs(lst, geometry=[2, 2], ww=None, raisewindows=False, tofront=False, verbose=0, monitorindex=None)[source]

Tile figure windows on a specified area

Parameters:

lst (list) – list of figure handles or integers
geometry (2x1 array) – layout of windows
int) (monitorindex (None or) –
list) (ww (None or) –

qtt.pgeometry.tprint(string: str, dt: float = 1, output: bool = False, tag: str = 'default') → bool | None[source]

Print progress of a loop every dt seconds

Parameters:

string – text to print
dt – delta time in seconds
output – if True return whether output was printed or not
tag – optional tag for time

Returns:

Output (bool) or None

qtt.pgeometry.writeTxt(im, txt, pos=(10, 10), fontsize=25, color=(0, 0, 0), fonttype=None)[source]: Write text on image using PIL

qtt.structures module

Contains code for various structures

class qtt.structures.CombiParameter(name, params, label=None, unit='a.u.', **kwargs)[source]

Bases: Parameter

Create a parameter which is a combination of multiple other parameters, which are always set to the same value.

The get function returns the mean of the individual parameters.

name

name for the parameter

Type:: str

params

the parameters to combine

Type:: list

get_raw()[source]: get_raw is called to perform the actual data acquisition from the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if get_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a get method on the parameter instance.

set_raw(value)[source]: set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

class qtt.structures.MultiParameter(name, params, label=None, unit=None, **kwargs)[source]

Bases: Parameter

Create a parameter which is a combination of multiple other parameters.

name

name for the parameter

Type:: str

params

the parameters to combine

Type:: list

get_raw()[source]: get_raw is called to perform the actual data acquisition from the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if get_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a get method on the parameter instance.

set_raw(values)[source]: set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

class qtt.structures.VectorParameter(name, comb_map, **kwargs)[source]

Bases: Parameter

Create parameter which controls linear combinations.

name

the name given to the new parameter

Type:: str

comb_map

tuples with in the first entry a parameter and in the second a coefficient

Type:: list

coeffs_sum

the sum of all the coefficients

Type:: float

get_raw()[source]: Return the value of this parameter.

set_raw(value)[source]

Set the parameter to value.

Note: the set is not unique, i.e. the result of this method depends on the previous value of this parameter.

Parameters:: value (float) – the value to set the parameter to.

class qtt.structures.onedot_t(gates, name=None, data=None, station=None, transport_instrument=None)[source]

Bases: dict

Class representing a single quantum dot

name()[source]

class qtt.structures.sensingdot_t(gate_names, gate_values=None, station=None, index=None, minstrument=None, virt_gates=None)[source]

Bases: object

autoTune(scanjob=None, fig=200, outputdir=None, step=-2.0, max_wait_time=1.0, scanrange=300, add_slopes=False)[source]: Automatically determine optimal value of plunger

autoTuneInit(scanjob, mode='center')[source]

detune(value)[source]: Detune the sensing dot by the specified amount

detuning_scan(stepsize=2, nsteps=5, verbose=1, fig=None)[source]

Optimize the sensing dot by making multiple plunger scans for different detunings

Parameters:

stepsize (float) –
nsteps (int) –

Returns:

list of optimal detuning and sd plunger value results (dict)

Return type:

best (list)

fastTune(Naverage=90, sweeprange=79, period=0.001, location=None, fig=201, sleeptime=2, delete=True, add_slopes=False, invert=False, verbose=1)[source]

Fast tuning of the sensing dot plunger.

If the sensing dot object is initialized with a virtual gates object the virtual plunger will be used for the sweep.

Parameters:

Naverage (int) – number of averages
scanrange (float) – Range to be used for scanning
period (float) – Period to be used in the scan sweep
fig (int or None) – window for plotting results

Returns:

value of plunger alldata (dataset): measured data

Return type:

plungervalue (float)

gate_names()[source]: Return names of the gates used to the define the SD

gates()[source]: Return values on the gates used to the define the SD

initialize(sdval=None, setPlunger=False)[source]

plungervalue()[source]: Return current value of the chemical potential plunger

scan1D(outputdir=None, step=-2.0, max_wait_time=0.75, scanrange=300)[source]: Make 1D-scan of the sensing dot.

scan2D(ds=90, stepsize=4, fig=None, verbose=1)[source]: Make 2D-scan of the sensing dot.

show()[source]

tunegate()[source]: Return the gate used for tuning the potential in the dot

value()[source]: Return current through sensing dot

class qtt.structures.twodot_t(*args, **kwargs)[source]

Bases: dict

name()[source]

qtt package

Subpackages

Submodules

qtt.data module

qtt.dataset_processing module

qtt.exceptions module

qtt.pgeometry module

pgeometry

qtt.structures module

qtt.version module