qutip_qtrl.pulsegen

Pulse generator - Generate pulses for the timeslots Each class defines a gen_pulse function that produces a float array of size num_tslots. Each class produces a differ type of pulse. See the class and gen_pulse function descriptions for details

Functions

create_pulse_gen([pulse_type, dyn, pulse_params])

Create and return a pulse generator object matching the given type.

Classes

PulseGen([dyn, params])	Pulse generator Base class for all Pulse generators The object can optionally be instantiated with a Dynamics object, in which case the timeslots and amplitude scaling and offset are copied from that.
PulseGenCrab([dyn, num_coeffs, params])	Base class for all CRAB pulse generators Note these are more involved in the optimisation process as they are used to produce piecewise control amplitudes each time new optimisation parameters are tried
PulseGenCrabFourier([dyn, num_coeffs, ...])	Generates a pulse using the Fourier basis functions, i.e. sin and cos.
PulseGenGaussian([dyn, params])	Generates pulses with a Gaussian profile
PulseGenGaussianEdge([dyn, params])	Generate pulses with inverted Gaussian ramping in and out It's intended use for a ramping modulation, which is often required in experimental setups.
PulseGenLinear([dyn, params])	Generates linear pulses
PulseGenPeriodic([dyn, params])	Intermediate class for all periodic pulse generators All of the periodic pulses range from -1 to 1 All have a start phase that can be set between 0 and 2pi
PulseGenRandom([dyn, params])	Generates random pulses as simply random values for each timeslot
PulseGenRndFourier([dyn, params])	Generates pulses by summing sine waves as a Fourier series with random coefficients
PulseGenRndWalk1([dyn, params])	Generates pulses by using a random walk algorithm
PulseGenRndWalk2([dyn, params])	Generates pulses by using a random walk algorithm Note this is best used with bounds as the walks tend to wander far
PulseGenRndWaves([dyn, params])	Generates pulses by summing sine waves with random frequencies amplitudes and phase offset
PulseGenSaw([dyn, params])	Generates saw tooth wave pulses
PulseGenSine([dyn, params])	Generates sine wave pulses
PulseGenSquare([dyn, params])	Generates square wave pulses
PulseGenTriangle([dyn, params])	Generates triangular wave pulses
PulseGenZero([dyn, params])	Generates a flat pulse

class qutip_qtrl.pulsegen.PulseGen(dyn=None, params=None)

Pulse generator Base class for all Pulse generators The object can optionally be instantiated with a Dynamics object, in which case the timeslots and amplitude scaling and offset are copied from that. Otherwise the class can be used independently by setting: tau (array of timeslot durations) or num_tslots and pulse_time for equally spaced timeslots

Attributes:

num_tslotsinteger

Number of timeslots, aka timeslices (copied from Dynamics if given)

pulse_timefloat

total duration of the pulse (copied from Dynamics.evo_time if given)

scalingfloat

linear scaling applied to the pulse (copied from Dynamics.initial_ctrl_scaling if given)

offsetfloat

linear offset applied to the pulse (copied from Dynamics.initial_ctrl_offset if given)

tauarray[num_tslots] of float

Duration of each timeslot (copied from Dynamics if given)

lboundfloat

Lower boundary for the pulse amplitudes Note that the scaling and offset attributes can be used to fully bound the pulse for all generators except some of the random ones This bound (if set) may result in additional shifting / scaling Default is -Inf

uboundfloat

Upper boundary for the pulse amplitudes Note that the scaling and offset attributes can be used to fully bound the pulse for all generators except some of the random ones This bound (if set) may result in additional shifting / scaling Default is Inf

periodicboolean

True if the pulse generator produces periodic pulses

randomboolean

True if the pulse generator produces random pulses

log_levelinteger

level of messaging output from the logger. Options are attributes of qutip_qtrl.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN

apply_params(params=None)

Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value

gen_pulse()

returns the pulse as an array of vales for each timeslot Must be implemented by subclass

init_pulse()

Initialise the pulse parameters

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenCrab(dyn=None, num_coeffs=None, params=None)

Base class for all CRAB pulse generators Note these are more involved in the optimisation process as they are used to produce piecewise control amplitudes each time new optimisation parameters are tried

Attributes:

num_coeffsinteger

Number of coefficients used for each basis function

num_basis_funcsinteger

Number of basis functions In this case set at 2 and should not be changed

coeffsfloat array[num_coeffs, num_basis_funcs]

The basis coefficient values

randomize_coeffsbool

If True (default) then the coefficients are set to some random values when initialised, otherwise they will all be equal to self.scaling

estimate_num_coeffs(dim)

Estimate the number coefficients based on the dimensionality of the system. :returns: num_coeffs – estimated number of coefficients :rtype: int

get_optim_var_vals()

Get the parameter values to be optimised :rtype: list (or 1d array) of floats

init_coeffs(num_coeffs=None, init_coeffs=None)

Generate or set the initial ceofficent values.

Parameters:

num_coeffsinteger

Number of coefficients used for each basis function If given this overides the default and sets the attribute of the same name.

init_coeffsfloat array[num_coeffs * num_basis_funcs]

Typically this will be the initial basis coefficients. If set to None (the default), the initial coefficients will be automatically generated.

init_pulse(num_coeffs=None, init_coeffs=None)

Set the initial freq and coefficient values

reset()

reset attributes to default values

set_optim_var_vals(param_vals)

Set the values of the any of the pulse generation parameters based on new values from the optimisation method Typically this will be the basis coefficients

class qutip_qtrl.pulsegen.PulseGenCrabFourier(dyn=None, num_coeffs=None, params=None, fix_freqs=True)

Generates a pulse using the Fourier basis functions, i.e. sin and cos

Attributes:

freqsfloat array[num_coeffs]

Frequencies for the basis functions

randomize_freqsbool

If True (default) the some random offset is applied to the frequencies

fix_freqsbool

If True (default) then the frequencies of the basis functions are fixed and the number of basis functions is set to 2 (sin and cos). If False then the frequencies are also optimised, adding an additional parameter for each pair of basis functions.

gen_pulse(coeffs=None)

Generate a pulse using the Fourier basis with the freqs and coeffs attributes.

Parameters:

coeffsfloat array[num_coeffs, num_basis_funcs]

The basis coefficient values If given this overides the default and sets the attribute of the same name.

init_freqs()

Generate the frequencies These are the Fourier harmonics with a uniformly distributed random offset

init_pulse(num_coeffs=None, init_coeffs=None)

Set the initial freq and coefficient values

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenGaussian(dyn=None, params=None)

Generates pulses with a Gaussian profile

gen_pulse(mean=None, variance=None)

Generate a pulse with Gaussian shape. The peak is centre around the mean and the variance determines the breadth The scaling and offset attributes are applied as an amplitude and fixed linear offset. Note that the maximum amplitude will be scaling + offset.

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenGaussianEdge(dyn=None, params=None)

Generate pulses with inverted Gaussian ramping in and out It’s intended use for a ramping modulation, which is often required in experimental setups.

Attributes:

decay_timefloat

Determines the ramping rate. It is approximately the time required to bring the pulse to full amplitude It is set to 1/10 of the pulse time by default

gen_pulse(decay_time=None)

Generate a pulse that starts and ends at zero and 1.0 in between then apply scaling and offset The tailing in and out is an inverted Gaussian shape

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenLinear(dyn=None, params=None)

Generates linear pulses

Attributes:

gradientfloat

Gradient of the line. Note this is calculated from the start_val and end_val if these are given

start_valfloat

Start point of the line. That is the starting amplitude

end_valfloat

End point of the line. That is the amplitude at the start of the last timeslot

gen_pulse(gradient=None, start_val=None, end_val=None)

Generate a linear pulse using either the gradient and start value or using the end point to calulate the gradient Note that the scaling and offset parameters are still applied, so unless these values are the default 1.0 and 0.0, then the actual gradient etc will be different Returns the pulse as an array of vales for each timeslot

init_pulse(gradient=None, start_val=None, end_val=None)

Calculate the gradient if pulse is defined by start and end point values

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenPeriodic(dyn=None, params=None)

Intermediate class for all periodic pulse generators All of the periodic pulses range from -1 to 1 All have a start phase that can be set between 0 and 2pi

Attributes:

num_wavesfloat

Number of complete waves (cycles) that occur in the pulse. wavelen and freq calculated from this if it is given

wavelenfloat

Wavelength of the pulse (assuming the speed is 1) freq is calculated from this if it is given

freqfloat

Frequency of the pulse

start_phasefloat

Phase of the pulse signal when t=0

init_pulse(num_waves=None, wavelen=None, freq=None, start_phase=None)

Calculate the wavelength, frequency, number of waves etc from the each other and the other parameters If num_waves is given then the other parameters are worked from this Otherwise if the wavelength is given then it is the driver Otherwise the frequency is used to calculate wavelength and num_waves

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenRandom(dyn=None, params=None)

Generates random pulses as simply random values for each timeslot

gen_pulse()

Generate a pulse of random values between 1 and -1 Values are scaled using the scaling property and shifted using the offset property Returns the pulse as an array of vales for each timeslot

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenRndFourier(dyn=None, params=None)

Generates pulses by summing sine waves as a Fourier series with random coefficients

Attributes:

scalingfloat

The pulses should fit approximately within -/+scaling (before the offset is applied) as it is used to set a maximum for each component wave Use bounds to be sure (copied from Dynamics.initial_ctrl_scaling if given)

min_wavelenfloat

Minimum wavelength of any component wave Set by default to 1/10th of the pulse time

gen_pulse(min_wavelen=None)

Generate a random pulse based on a Fourier series with a minimum wavelength

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenRndWalk1(dyn=None, params=None)

Generates pulses by using a random walk algorithm

Attributes:

scalingfloat

Used as the range for the starting amplitude Note must used bounds if values must be restricted. Also scales the max_d_amp value (copied from Dynamics.initial_ctrl_scaling if given)

max_d_ampfloat

Maximum amount amplitude will change between timeslots Note this is also factored by the scaling attribute

gen_pulse(max_d_amp=None)

Generate a pulse by changing the amplitude a random amount between -max_d_amp and +max_d_amp at each timeslot. The walk will start at a random amplitude between -/+scaling.

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenRndWalk2(dyn=None, params=None)

Generates pulses by using a random walk algorithm Note this is best used with bounds as the walks tend to wander far

Attributes:

scalingfloat

Used as the range for the starting amplitude Note must used bounds if values must be restricted. Also scales the max_d2_amp value (copied from Dynamics.initial_ctrl_scaling if given)

max_d2_ampfloat

Maximum amount amplitude gradient will change between timeslots Note this is also factored by the scaling attribute

gen_pulse(init_grad_range=None, max_d2_amp=None)

Generate a pulse by changing the amplitude gradient a random amount between -max_d2_amp and +max_d2_amp at each timeslot. The walk will start at a random amplitude between -/+scaling. The gradient will start at 0

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenRndWaves(dyn=None, params=None)

Generates pulses by summing sine waves with random frequencies amplitudes and phase offset

Attributes:

scalingfloat

The pulses should fit approximately within -/+scaling (before the offset is applied) as it is used to set a maximum for each component wave Use bounds to be sure (copied from Dynamics.initial_ctrl_scaling if given)

num_comp_wavesinteger

Number of component waves. That is the number of waves that are summed to make the pulse signal Set to 20 by default.

min_wavelenfloat

Minimum wavelength of any component wave Set by default to 1/10th of the pulse time

max_wavelenfloat

Maximum wavelength of any component wave Set by default to twice the pulse time

gen_pulse(num_comp_waves=None, min_wavelen=None, max_wavelen=None)

Generate a random pulse by summing sine waves with random freq, amplitude and phase offset

reset()

reset attributes to default values

class qutip_qtrl.pulsegen.PulseGenSaw(dyn=None, params=None)

Generates saw tooth wave pulses

gen_pulse(num_waves=None, wavelen=None, freq=None, start_phase=None)

Generate a saw tooth wave pulse If no parameters are pavided then the class object attributes are used. If they are provided, then these will reinitialise the object attribs

class qutip_qtrl.pulsegen.PulseGenSine(dyn=None, params=None)

Generates sine wave pulses

gen_pulse(num_waves=None, wavelen=None, freq=None, start_phase=None)

Generate a sine wave pulse If no params are provided then the class object attributes are used. If they are provided, then these will reinitialise the object attribs. returns the pulse as an array of vales for each timeslot

class qutip_qtrl.pulsegen.PulseGenSquare(dyn=None, params=None)

Generates square wave pulses

gen_pulse(num_waves=None, wavelen=None, freq=None, start_phase=None)

Generate a square wave pulse If no parameters are pavided then the class object attributes are used. If they are provided, then these will reinitialise the object attribs

class qutip_qtrl.pulsegen.PulseGenTriangle(dyn=None, params=None)

Generates triangular wave pulses

gen_pulse(num_waves=None, wavelen=None, freq=None, start_phase=None)

Generate a triangular wave pulse If no parameters are pavided then the class object attributes are used. If they are provided, then these will reinitialise the object attribs

class qutip_qtrl.pulsegen.PulseGenZero(dyn=None, params=None)

Generates a flat pulse

gen_pulse()

Generate a pulse with the same value in every timeslot. The value will be zero, unless the offset is not zero, in which case it will be the offset

qutip_qtrl.pulsegen.create_pulse_gen(pulse_type='RND', dyn=None, pulse_params=None)

Create and return a pulse generator object matching the given type. The pulse generators each produce a different type of pulse, see the gen_pulse function description for details. These are the random pulse options:

RND - Independent random value in each timeslot RNDFOURIER - Fourier series with random coefficients RNDWAVES - Summation of random waves RNDWALK1 - Random change in amplitude each timeslot RNDWALK2 - Random change in amp gradient each timeslot

These are the other non-periodic options:

LIN - Linear, i.e. contant gradient over the time ZERO - special case of the LIN pulse, where the gradient is 0

These are the periodic options

SINE - Sine wave SQUARE - Square wave SAW - Saw tooth wave TRIANGLE - Triangular wave

If a Dynamics object is passed in then this is used in instantiate the PulseGen, meaning that some timeslot and amplitude properties are copied over.