qtt.simulation package

Modules related to simulation

Submodules

qtt.simulation.classicaldotsystem module

Classical Quantum Dot Simulator

@author: lgnjanssen / eendebakpt / hensgens

class qtt.simulation.classicaldotsystem.ClassicalDotSystem(name='dotsystem', ndots=3, ngates=3, maxelectrons=3, **kwargs)

Bases: qtt.simulation.dotsystem.BaseDotSystem

calculate_energies(gatevalues)

Calculate the energies of all dot states, given a set of gate values. Returns array of energies.

calculate_ground_state(gatevalues)

Calculate the ground state of the dot system, given a set of gate values. Returns a state array.

findcurrentoccupancy(exact=True)

Find electron occupancy

Parameters:exact (bool) – If True then average over all ground states

simulate_honeycomb(paramvalues2D, verbose=1, usediag=False, multiprocess=True)

Simulating a honeycomb by looping over a 2D array of parameter values (paramvalues2D), resulting honeycomb is stored in self.honeycomb

Parameters:

• paramvalues2D (array) – shape nparams x nx x ny
• verbose (int) –
• usediag (bool) –
• multiprocess (bool) –

solve()

class qtt.simulation.classicaldotsystem.DoubleDot(name='doubledot', **kwargs)

Bases: qtt.simulation.classicaldotsystem.ClassicalDotSystem

Classical simulation of double dot

class qtt.simulation.classicaldotsystem.MultiDot(name='multidot', ndots=6, maxelectrons=3, **kwargs)

Bases: qtt.simulation.classicaldotsystem.ClassicalDotSystem

class qtt.simulation.classicaldotsystem.SquareDot(name='squaredot', **kwargs)

Bases: qtt.simulation.classicaldotsystem.ClassicalDotSystem

class qtt.simulation.classicaldotsystem.TripleDot(name='tripledot', maxelectrons=2, **kwargs)

Bases: qtt.simulation.classicaldotsystem.ClassicalDotSystem

qtt.simulation.classicaldotsystem.ncr(n, r)

Calculating number of possible combinations: n choose r

qtt.simulation.dotsystem module

Simulation of a coupled dot system.

class qtt.simulation.dotsystem.BaseDotSystem

Bases: object

Base class for the dot simulation classes.

Based on the arguments the system calculates the energies of the different dot states. Using the energies the ground state, occupancies etc. can be calculated. The spin-state of electrons in the dots is ignored.

The main functionality:

• Build a Hamiltonian from the number of dots
• Solve for the eigenvalues and eigenstates of the Hamiltonian
• Present the results.

The model used is [reference xxx].

number_of_basis_states

number of basis states.

Type:int

H

Hamiltonian of the system.

Type:array

energies

calculated energy for each state (ordered).

Type:array

states

eigenstates expressed in the basis states.

Type:array

stateprobs

TODO.

Type:array

stateoccs

TODO.

Type:array

nstates

for each state the number of electrons.

Type:array

calculate_ground_state(gatevalues)

Calculate ground state for a set of gate values.

findtransitions(occs)

Find transitions in occupancy image.

makebasis(ndots, maxelectrons=2)

Define a basis of occupancy states with a specified number of dots and max occupancy.

The basis consists of vectors of length (ndots) where each entry in the vector indicates the number of electrons in a dot. The number of electrons in the total system is specified in nbasis.

orderstatesbyE()

Order the calculated states by energy.

orderstatesbyN()

Order the calculated states by occupation.

showstates(n)

List states of the system with energies.

class qtt.simulation.dotsystem.DotSystem(name='dotsystem', ndots=3, **kwargs)

Bases: qtt.simulation.dotsystem.BaseDotSystem

calculate_energies(gatevalues)

Calculate energies of the different states in the system.

Parameters:gatevalues (list) – values for the chemical potentials in the dots.

calculate_ground_state(gatevalues)

Calculate the ground state of the dot system, given a set of gate values.

Parameters:gatevalues (list) – values for the chemical potentials in the dots. Returns:a state array. Return type:array

static chemical_potential_matrix(dot)

static chemical_potential_name(dot) → str

findcurrentoccupancy(exact=True)

getHn(numberofelectrons)

get_chemical_potential(dot)

get_on_site_charging(dot)

getall(param)

Return all stored values for a particular parameter.

Parameters:param (str) – start of one of the variable names. Returns:values corresponding to the parameter that was queried. Return type:vals (list)

initSparse()

Create sparse structures. Constructing a matrix using sparse elements can be faster than construction of a full matrix, especially for larger systems.

static inter_site_charging_matrix(dot1, dot2=None)

static inter_site_charging_name(dot1, dot2=None)

Return name for nearest - neighbour charging energy.

makeH()

Create a new Hamiltonian.

makeHsparse(verbose=0)

Create a new sparse Hamiltonian.

make_variables()

Create value and matrix for a single variable.

makeparamvalues1D(paramnames, startend, npoints)

Get a list of parameter names and [start end] values to generate dictionary self.vals1D[name] = vector of values.

makeparamvalues2D(paramnames, cornervals, npointsx, npointsy)

Get a list of parameter names and [c1 c2 c3 c4] ‘corner’ values to generate dictionary self.vals2D[name] = matrix of values.

static on_site_charging_matrix(dot)

static on_site_charging_name(dot)

resetMu(value=0)

Reset chemical potential. :param value: TODO. :type value: int

set_chemical_potential(dot, value)

set_on_site_charging(dot, value)

setall(param, vals)

Sets all values for a particular parameter.

Parameters:

• param (str) – start of one of the variable names.
• vals (list) – values corresponding to the parameter to be set.

showMmatrix(name=None, fig=10)

showvars()

simulate_honeycomb(paramvalues2D, verbose=1, usediag=False, multiprocess=True)

simulatehoneycomb(verbose=1, usediag=False, multiprocess=False)

Loop over the 2D matrix of parameter values defined by makeparamvalues2D, calculate the ground state for each point, search for transitions and save in self.honeycomb.

simulatehoneycomb_original(verbose=1, usediag=False)

Loop over the 2D matrix of parameter values defined by makeparamvalues2D, calculate the ground state

for each point, search for transitions and save in self.honeycomb.

Parameters:

• verbose (int) – verbosity (0 == silent).
• usediag (bool) – TODO.

solveH(usediag=False)

Solve the system by calculating the eigenvalues and eigenstates of the Hamiltonian.

Parameters:usediag (bool) – TODO.

static tunneling_matrix(dot_left)

static tunneling_name(dot_left)

visualize(fig=1)

Create a graphical representation of the system (needs graphviz).

Parameters:fig (int) – figure number, None is silent.

class qtt.simulation.dotsystem.DoubleDot(name='doubledot', maxelectrons=3)

Bases: qtt.simulation.dotsystem.DotSystem

class qtt.simulation.dotsystem.FourDot(name='fourdot', use_tunneling=True, **kwargs)

Bases: qtt.simulation.dotsystem.DotSystem

class qtt.simulation.dotsystem.GateTransform(Vmatrix, sourcenames, targetnames)

Bases: object

transformGateScan(vals2D, nn=None)

Get a list of parameter names and [c1 c2 c3 c4] ‘corner’ values to generate dictionary self.vals2D[name] = matrix of values.

Parameters:

• vals2D (dict) – keys are the gate names, values are matrices with the gate values.
• nn – TODO.

Returns:

tranformed gate values.

Return type:

dict

class qtt.simulation.dotsystem.OneDot(name='doubledot', maxelectrons=3)

Bases: qtt.simulation.dotsystem.DotSystem

class qtt.simulation.dotsystem.TripleDot(name='tripledot', maxelectrons=3)

Bases: qtt.simulation.dotsystem.DotSystem

class qtt.simulation.dotsystem.TwoXTwo(name='2x2')

Bases: qtt.simulation.dotsystem.DotSystem

qtt.simulation.dotsystem.defaultDotValues(ds)

qtt.simulation.dotsystem.defaultVmatrix(n)

Helper function. >>> m=defaultVmatrix(2)

qtt.simulation.dotsystem.isdiagonal(HH)

Return True if matrix is diagonal.

qtt.simulation.dotsystem.setDotSystem(ds, gate_transform, gv)

Set dot system values using gate transform.

qtt.simulation.dotsystem.showGraph(dot, fig=10)

Show graphviz object in matplotlib window.

qtt.simulation.dotsystem.static_var(varname, value)

Helper function to create a static variable.

qtt.simulation.dotsystem.tprint(string, dt=1, output=False)

Print progress of a loop every dt seconds.

qtt.simulation.virtual_dot_array module

Virtual version of a linear dot array

The system consists of:

• a linear array of dots
• a magic top gate that always works
• 2 barriers gates and 1 plunger gate for each dot
• a sensing dot that always works

There are virtual instruments for

• DACs: several virtual IVVIs
• Virtual Keithleys (1 and 2 for the SDs, 4 for the ohmic)
• A virtual gates object

class qtt.simulation.virtual_dot_array.DotModel(name, verbose=0, nr_dots=3, maxelectrons=2, sdplunger=None, **kwargs)

Bases: qcodes.instrument.base.Instrument

Simulation model for linear dot array

The model is intended for testing the code and learning. It does _not simulate any meaningful physics.

compute(random=0.02)

Compute output of the model

computeSD(usediag=True, verbose=0)

gate2ivvi(g)

gate2ivvi_value(g)

get_gate(g)

get_idn()

Overrule because the default get_idn yields a warning

honeycomb(p1, p2, nx=50, ny=50, scanrange=300, multiprocess=False)

keithley1_get(param)

keithley2_get(param)

keithley3_get(param)

keithley4_get(param)

qtt.simulation.virtual_dot_array.bottomBarrierGates()

qtt.simulation.virtual_dot_array.bottomGates()

qtt.simulation.virtual_dot_array.boundaries()

qtt.simulation.virtual_dot_array.close(verbose=1)

Close all instruments

qtt.simulation.virtual_dot_array.gate_boundaries(gate_map)

Return gate boundaries

Parameters:gate_map (dict) – Returns:gate_boundaries (dict)

qtt.simulation.virtual_dot_array.gate_settle(gate)

Return gate settle times

qtt.simulation.virtual_dot_array.generate_configuration(ndots)

Generate configuration for a standard linear dot array sample

Parameters:ndots (int) – number of dots Returns:number_dac_modules (int) gate_map (dict) gates (list) bottomgates (list)

qtt.simulation.virtual_dot_array.getStation()

qtt.simulation.virtual_dot_array.get_one_dots(full=1, sdidx=None)

return all possible simple one-dots

Each dot objects holds the gates, the name of the channel and the instrument measuring over the channel.

qtt.simulation.virtual_dot_array.get_two_dots()

return all possible simple two-dots

qtt.simulation.virtual_dot_array.initialize(reinit=False, nr_dots=2, maxelectrons=2, verbose=2, start_manager=False)