oxfordiontrapgroup/oitg

Python package of helper routines (result loading, fitting, etc) for the Oxford Ion-Trap Group (OITG).

Oxford Ion-Trap Group routines

Contains common routines and convenience functions used in the Oxford Ion Trap Quantum Computing group.

• ARTIQ result file loading
• Fitting routines
• Generation of qubit circuits for a variety of protocols, and analysis/visualisation of the results

To view the API documentation, run

$ cd docs/
$ make html

and open docs/_build/html/index.html in a web browser. (Builds of the most recent main repository master branch commit are also available online at https://oxfordiontrapgroup.github.io/oitg/.)

oitg's Issues

FitBase: pass constants and user initialised parameters to parameter_initialiser

It would be useful for parameters that are held constant/initialised via the FitBase.fit arguments to be passed to the parameter_initialiser. This would allow the parameter_initialiser to improve estimates based on user information.

`fitting.parabola` does not calculate extremum position error

oitg/oitg/fitting/parabola.py

Lines 22 to 39 in 26e047e

	def derived_parameter_function(p, p_error):
	# Calculate position of the extremum
	x_ext = -p['b']/(2*p['c'])
	# x_ext_error = x_ext*np.sqrt((p_error['b']/p['b'])**2
	# + (p_error['c']/p['c'])**2)
	y_ext = p['a']
	y_ext += p['b']*x_ext
	y_ext += p['c']*x_ext**2
	#y_ext_error =
	p['x_ext'] = x_ext
	p['y_ext'] = y_ext
	return p, p_error

Global Fit Optimisation Routine

We may want a routine for global fit optimisation of binomial (or other) distributed data.

This should give the global optimum parameter estimates and their covariances. Ideally, it should be capable of producing a plot of P(parameters|data).

Broken out from this issue

documentation: document fitting.sinusoid parameters properly

Description of phi is not particularly clear, a isn't mentioned in the doc string etc

Line fitting fails for two data points

The following code fails

from oitg.fitting import line
line.fit([0,1],[0,1])

with error

Traceback (most recent call last):
  File "C:\Users\LocalAdmin\Miniconda3\envs\artiq-env\lib\site-packages\oitg-0.1-py3.9.egg\oitg\fitting\FitBase.py", line 249, in fit
  File "C:\Users\LocalAdmin\Miniconda3\envs\artiq-env\lib\site-packages\scipy\optimize\minpack.py", line 795, in curve_fit
    res = least_squares(func, p0, jac=jac, bounds=bounds, method=method,
  File "C:\Users\LocalAdmin\Miniconda3\envs\artiq-env\lib\site-packages\scipy\optimize\_lsq\least_squares.py", line 805, in least_squares
    raise ValueError("`x0` is infeasible.")
ValueError: `x0` is infeasible.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "y:/testing/scratch_mfg/line_fit.py", line 2, in <module>
    line.fit([0,1],[0,1])
  File "C:\Users\LocalAdmin\Miniconda3\envs\artiq-env\lib\site-packages\oitg-0.1-py3.9.egg\oitg\fitting\FitBase.py", line 255, in fit
oitg.fitting.FitBase.FitError: `x0` is infeasible.

One obvious thing that would fail is the parameter_initialiser in line.py

oitg/oitg/fitting/line.py

Lines 6 to 9 in 9b64b4e

	def parameter_initialiser(x, y, p):
	k = (y[-1] - y[1]) / (x[-1] - x[1])
	p['a'] = y[1] - x[1] * k
	p['b'] = k

which would give division by 0 errors for a size two array.

Error for Loading results

oitg/oitg/rid_index.py

Line 33 in 768b2d5

if previous_path := index.get(rid):

Is this line supposed to be "!=" or "=" instead of ":="? Changing to "!=" allows me to load results, while leaving it as is gives an error.

Gradient descent based fitting for non-gaussian distributions

It would be usefult to have a parameter inference function that does not assume gaussian errors.

Common examples are: binomial dristribution & Poisson distribution

v_function: improve heuristics

The heuristics for v_function are currently not great.

Thoughts

• API: currently the v function is described by positive and negative gradients. IMHO that's non-ideal since there isn't an easy way to constrain the fit to be symmetric. Might be better to do something like a gradient and an asymmetry factor (which can usually default to 1)
• putting x0 as mean(x) only works if the v function is decently well centred. I've found this to be pretty fragile
• similarly, putting the offset as the mean of y doesn't work that well in my experience
• maybe a better way is to first figure out which way up the v function is (maybe add a sign parameter so users can specify this, and then enforce that the other gradients are strictly positive). once we know that we can easily generate good guesses for the other parameters
• maybe one way of guessing which way up it is is to find the min/max points, then look at the max/max on either side of them. e.g. on a downwards v function, should have higher points on either side of the minimum. This doesn't work if the minimum is off the end of the dataset in one direction, but I don't see an obviously better way (other than just try fitting for both signs and see which gives lower residuals).

I'd be interested in input on better ideas if people have them?

FitBase should pass covariance matrix to the derived_parameter_function

Covariences may have a significant effect on the error calculated for a derived parameter. It would be good to have the covariance matrix calculated by curve_fit availible in the derived_parameter_function.

exponential_decay: `t_1_e` error propagation

I'm pretty sure the divide by 2 shouldn't be there...

oitg/oitg/fitting/exponential_decay.py

Lines 28 to 29 in 26e047e

	# This is just a Gaussian error propagation guess.
	p_err["t_1_e"] = np.sqrt(p_err["x0"]**2 + (p_err["tau"] / 2)**2)

FitBase: expose **kwargs of curve_fit

Fitting with parameter values far from unity can be improved by passing characteristic parameter scales to curve_fit using the optional the x_scale keyword argument.
This argument is documneted under scipy.optimize.least_squares. curve_fit calls this function internally. **kwargs to curve_fit are passed to scipy.optimize.least_squares.

oitg/fitting/dipole_bsb_car_rsb should use relative imports

oitg/fitting/dipole_bsb_car_rsb.py should use
from .FitBase import FitBase
insead of
from FitBase import FitBase

fitting: depreciate sin/cos in favor of fitting.sinusoid

Check with users to see if anyone is still using these old routines

Account for spontaneous shelving and deshelving in threshold.py

As per title.

Currently threshold.py assumes poissonian statistics. This is innacurate for longer readout durations.

Calculateing Binomial Data-Point Confidence Interval

There should be a function calculating the confidence interval for a binomial data-point. (for plotting purposes)

This post seems to suggest the right thing.

Broken out from this issue

upstream the results code

Looks clean, generic, and mature. Is ARTIQ-specific but experiment-agnostic.
Any chance to get a PR for it?

(maybe without artiq_results_path())

Timeresolved Readout Routines

Routines for time resolved readout, accounting for (user specified) erroneous shelving and deshelving rates.

The routines should:

• Determine whether a readout event was bright or dark.
• Provide an appropreate readout duration for a target readout error.

It may be useful to implement binomial confidence intervals and non-gaussian error fitting before implementing this.

Robust sinc^2-like frequency scan fit for arbitrary pulse areas

It would be nice to have a robust way of fitting the spectra from scanning over a two-level-like transition with constant pulse area (i.e. sinc^2-like if area is exactly π).

I expect this to be a bit flaky if both pulse area and upper/lower levels are floated, but the user could always constrain these for better convergence.

oitg.fitting.sinusoid unit tests fail

As per the title; specifically test_delayed_split_data_with_t_dead fails deterministically: https://circleci.com/gh/OxfordIonTrapGroup/oitg/84

Fitting with no parameter bounds raises exception

Fits with no bounds call scipy leastsq instead of scipy least_squares. See curve_fit documentation

kwargs

Keyword arguments passed to leastsq for method='lm' or least_squares otherwise.

this case raises FitError: leastsq() got an unexpected keyword argument 'x_scale'

Proposed solution: set the method to always use scipy least_squares