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/stable/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: Union[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: Optional[str], processing_function: Callable, label: Optional[str] = None, unit: Optional[str] = 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: Optional[str] = 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: Optional[float] = 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: Optional[Union[int, Figure]] = 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: Union[float, ndarray], cc: Optional[ndarray] = 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: Union[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: Optional[Union[float, str]], method: str = 'L1') → Union[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: Optional[float] = None, display_max: Optional[float] = 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

qtt.pgeometry.setWindowRectangle(x: Union[int, Sequence[int]], y: Optional[int] = None, w: Optional[int] = None, h: Optional[int] = None, fig: Optional[int] = None, mngr=None)[source]

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') → Optional[bool][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