def test_savetxt(self):
"""
Test saving a datacube to a text file
"""
for key in self.testCubes.keys():
print "Checking plain text loading of test cube {0!s}".format(key)
cube = self.testCubes[key]
filename = os.path.normpath(self.dataPath+"/test_{0!s}.txt".format(key))
cube.savetxt(filename,overwrite = True)
self.assert_(os.path.exists(filename),"File {0!s} has not been created!".format(filename))
self.assert_(os.path.isfile(filename))
restoredCube = Datacube()
restoredCube.loadtxt(filename)
self.assert_(restoredCube.equal(cube),"Error: Restored datacube does not match original one!")
class Instr(Instrument):
def saveState(self,name):
d=dict()
d['frequencies']=self._frequencies
return d
def restoreState(self,state):
self._frequencies=state['frequencies']
def addFrequency(self, f,name, useCorrection=False,bit=0):
"""
Add a new frequency to the analyser
"""
self._frequencies[name]=[f,True,bit]
return True
def startAnalyseFrequency(self,name):
self._frequencies[name][1]=True
def stopAnalyseFrequency(self,name):
self._frequencies[name][1]=False
def measureAll(self):
return self._acqiris.frequenciesAnalyse(frequencies=self._frequencies.values)
def analyse(self,nLoops=1,fast=False):
"""
Acquire and analyse the frequencies previously sent and returns (components and probabilities)
"""
maxBit=0
for v in self._frequencies.values():
if v[2]>maxBit and v[1]:
maxBit=v[2]
return self._acqiris.frequenciesAnalyse(frequencies=self._frequencies.values(),nLoops=nLoops,maxBit=maxBit,fast=fast)
def measureBifurcationProbabilities(self):
"""
Acquire, analyse the frequencies, convert it in clicks, and calculate averages values
"""
(av,co,fr)=self.analyse()
r=self._acqiris.multiplexedBifurcationMapAdd(co,fr)
p=self._acqiris.convertToProbabilities(r)
def clear(self):
"""
Clear the list of frequencies to be analysed and the calibration paramaters associated
"""
self._Ilist=[]
self._Qlist=[]
self._philist=[]
self._frequencies=dict()
def calibrateAmplitudeAndOffset(self,f):
"""
Only used when this pulse Analyser has to be used as real analyser, not when using it to see bifurcation
"""
rowData=Datacube()
for phi in arange(0,2*math.pi,math.pi/30):
print "calibration : phi = %f deg" % (phi/math.pi*180)
self._pulseGenerator.clearPulse()
self.clear()
self._pulseGenerator.generatePulse(duration=20000, frequency=f, amplitude=0.6, DelayFromZero=0,useCalibration=True, phase=phi)
self.addFrequency(f=f,useCorrection=False)
self._pulseGenerator.sendPulse()
time.sleep(0.5)
(av, co, fr)= self.analyse()
rowData.set(I=av[0,0], Q=av[1,0],phi=phi)
rowData.commit()
#I0=2/ptp(rowData['I'])
#Q0=2/ptp(rowData['Q'])
(I,Q,phi,dphi)=scipy.optimize.fmin_powell(lambda (I,Q,phi0,dphi): sum((I*rowData['I'] - sin(rowData['phi']+phi0+dphi))**2)+sum((Q*rowData['Q'] - cos(rowData['phi']+phi0))**2),(1,1,0,0))
print (I,Q,phi,dphi)
f_c=self._MWSource.frequency()
df=f-f_c
index=self._calibration.search(f_sb=df,f_c=f_c)
if index!=None:
self._calibration.removeRow(index)
self._calibration.set(I=I,Q=Q,phi=dphi,f_c=f_c,f_sb=df)
self._calibration.commit()
self._calibration.savetxt()
register['%s Cal'% self._name]=self._calibration.filename()
return rowData
def parameters(self):
"""
Returns intrument parameters
"""
return self._params
def initCal(self):
"""
Re-init the calibration when using this instrument as real analyser
"""
self._calibration=Datacube()
self._calibration.setName('analyser IQ mixer Calibration')
self._calibration.savetxt()
register['%s Cal'% self._name]=self._name.filename()
def initialize(self, name, acqiris, acqirisChannels, MWSource,pulse_generator):
"""
Initialize the instrument
"""
instrumentManager=Manager()
self._name=name
self._acqiris=instrumentManager.getInstrument(acqiris)
# self._acqiris("moduleDLL2.setChannels("+str(acqirisChannels[0])+","+str(acqirisChannels[1])+")")
self._acqiris.setChannels(acqirisChannels[0],acqirisChannels[1])
self._MWSource=instrumentManager.getInstrument(MWSource)
self._pulseGenerator=instrumentManager.getInstrument(pulse_generator)
self._params=dict()
self._params["acqiris"]=acqiris
self._params["MWSource"]=MWSource
self._frequencies=dict()
try:
self._calibration=Datacube()
self._calibration.setName('analyser IQ mixer Calibration')
self._calibration.loadtxt(register.parameters()['%s Cal'% self._name])
except:
pass
self._Ilist=[]
self._Qlist=[]
self._philist=[]
from pyview.lib.datacube import Datacube from matplotlib.pyplot import * from phdthesis.config.params import params from phdthesis.config.matplotlib.rcparams import * import sys titleString = "2 Qubit Anticrossing" outputFilename = "anticrossing" dataFile = r"data/Spectroscopy Survey - qubit1-7.txt" print "Loading data..." datacube = Datacube() datacube.loadtxt(dataFile) ## from numpy import * from numpy.linalg import * m1 = zeros((len(datacube.children()[0]),len(datacube))) m2 = zeros((len(datacube.children()[0]),len(datacube))) for i,child in enumerate(datacube.children()): m1[:,i] = child["p1x"] m2[:,i] = child["px1"] ##Generate a model of the qubit anticrossing
class Instr(Instrument):
def addFrequency(self, f,useCorrection=False):
"""
Add a new frequency to the analyser
"""
f_c=self._MWSource.frequency()
df=f-f_c
toReturn=True
if useCorrection:
if self._calibration.search(f_sb=df,f_c=f_c)==['']:
print 'Point not calibrated, calibration in progress.... (NOOOOO !! need to find a switch to calibrate ...)'
# self.calibrateAmplitudeAndOffset(f=f)
print 'calibration over'
toReturn=False
index=self._calibration.search(f_sb=df,f_c=f_c)
I=self._calibration['I'][index]
Q=self._calibration['Q'][index]
phi=self._calibration['phi'][index]
else:
I=1
Q=1
phi=0.
self._frequencies=append(self._frequencies,abs(df))
self._Ilist=append(self._Ilist,I)
self._Qlist=append(self._Qlist,Q)
self._philist=append(self._philist,phi)
return toReturn
def analyse(self):
"""
Acquire and analyse the frequencies previously sent and returns (waveforms, components, and frequencies analysed)
"""
(wa,av,co,fr)=self._acqiris.frequenciesAnalysis(frequencies=self._frequencies, Ilist=self._Ilist, Qlist=self._Qlist, philist=self._philist)
return (av, co, fr)
def measureBifurcationProbabilities(self):
"""
Acquire, analyse the frequencies, convert it in clicks, and calculate averages values
"""
(av,co,fr)=self.analyse()
r=self._acqiris.multiplexedBifurcationMapAdd(co,fr)
p=self._acqiris.convertToProbabilities(r)
def clear(self):
"""
Clear the list of frequencies to be analysed and the calibration paramaters associated
"""
self._Ilist=[]
self._Qlist=[]
self._philist=[]
self._frequencies=[]
def calibrateAmplitudeAndOffset(self,f):
"""
Only used when this pulse Analyser has to be used as real analyser, not when using it to see bifurcation
"""
rowData=Datacube()
for phi in arange(0,2*math.pi,math.pi/30):
print "calibration : phi = %f deg" % (phi/math.pi*180)
self._pulse_generator.clearPulse()
self.clear()
self._pulse_generator.generatePulse(duration=20000, frequency=f, amplitude=0.6, DelayFromZero=0,useCalibration=True, phase=phi)
self.addFrequency(f=f,useCorrection=False)
self._pulse_generator.sendPulse()
time.sleep(0.5)
(av, co, fr)= self.analyse()
rowData.set(I=av[0,0], Q=av[1,0],phi=phi)
rowData.commit()
#I0=2/ptp(rowData['I'])
#Q0=2/ptp(rowData['Q'])
(I,Q,phi,dphi)=scipy.optimize.fmin_powell(lambda (I,Q,phi0,dphi): sum((I*rowData['I'] - sin(rowData['phi']+phi0+dphi))**2)+sum((Q*rowData['Q'] - cos(rowData['phi']+phi0))**2),(1,1,0,0))
print (I,Q,phi,dphi)
f_c=self._MWSource.frequency()
df=f-f_c
index=self._calibration.search(f_sb=df,f_c=f_c)
if index!=None:
self._calibration.removeRow(index)
self._calibration.set(I=I,Q=Q,phi=dphi,f_c=f_c,f_sb=df)
self._calibration.commit()
self._calibration.savetxt()
register['%s Cal'% self._name]=self._calibration.filename()
return rowData
def parameters(self):
"""
Returns intrument parameters
"""
return self._params
def initCal(self):
"""
Re-init the calibration when using this instrument as real analyser
"""
self._calibration=Datacube()
self._calibration.setName('analyser IQ mixer Calibration')
self._calibration.savetxt()
register['%s Cal'% self._name]=self._name.filename()
def initialize(self, name, acqiris, MWSource,pulse_generator):
"""
Initialize the instrument
"""
instrumentManager=Manager()
self._name=name
self._acqiris=instrumentManager.getInstrument(acqiris)
self._MWSource=instrumentManager.getInstrument(MWSource)
self._pulse_generator=instrumentManager.getInstrument(pulse_generator)
self._params=dict()
self._params["acqiris"]=acqiris
self._params["MWSource"]=MWSource
self._frequencies=zeros(0)
try:
self._calibration=Datacube()
self._calibration.setName('analyser IQ mixer Calibration')
self._calibration.loadtxt(register.parameters()['%s Cal'% self._name])
except:
pass
self._Ilist=[]
self._Qlist=[]
self._philist=[]
string += "{"
for j in range(0, 4):
if j != 0:
string += ","
value = gv.spins.parameters()["densityMatrix"][i][j]
string += str(real(value)) + "+I*" + str(imag(value))
string += "}"
string += "}"
print string
##
from matplotlib.pyplot import *
from numpy import *
from pyview.lib.datacube import Datacube
cube = Datacube()
cube.loadtxt("State Tomography of Swap vs Swap Duration.txt")
##
print cube.structure()
##
def smooth(x, window_len=11, window='hanning'):
"""smooth the data using a window with requested size.
This method is based on the convolution of a scaled window with the signal.
The signal is prepared by introducing reflected copies of the signal
(with the window size) in both ends so that transient parts are minimized
in the begining and end part of the output signal.
input:
x: the input signal
from pyview.lib.datacube import Datacube
import matplotlib
import math
from numpy import *
import scipy.optimize
from quantum.qulib import *
import sys
matplotlib.use("module://pyview.gui.mpl.backend_static")
from matplotlib.pyplot import *
data1 = Datacube()
data1.loadtxt("IQ tomography-11")
data2 = Datacube()
data2.loadtxt("IQ tomography-12")
data3 = Datacube()
data3.loadtxt("IQ tomography-13")
data_array = [data1, data2, data3]
matrix_array = []
for i in range(0, len(data_array)):
data = data_array[i]
n = int(sqrt(len(data)))
m = zeros((n, n))
for i in range(0, n * n):
m[i % n, int(i / n)] = data["px1"][i]
string+=","
string+="{"
for j in range(0,4):
if j!=0:
string+=","
value = gv.spins.parameters()["densityMatrix"][i][j]
string+=str(real(value))+"+I*"+str(imag(value))
string+="}"
string+="}"
print string
##
from matplotlib.pyplot import *
from numpy import *
from pyview.lib.datacube import Datacube
cube = Datacube()
cube.loadtxt("State Tomography of Swap vs Swap Duration.txt")
##
print cube.structure()
##
def smooth(x,window_len=11,window='hanning'):
"""smooth the data using a window with requested size.
This method is based on the convolution of a scaled window with the signal.
The signal is prepared by introducing reflected copies of the signal
(with the window size) in both ends so that transient parts are minimized
in the begining and end part of the output signal.
input:
x: the input signal
window_len: the dimension of the smoothing window; should be an odd integer
