def fitFunc(self, x, p):
from labrad import units as U
flop = te.time_evolution(
trap_frequency=U.WithUnit(p[4], "MHz"), projection=p[7], sideband_order=p[5], nmax=p[6]
)
evolution = flop.state_evolution_fluc(x * 10 ** -6, p[0], p[1], p[2], p[3], n_fluc=5.0)
return evolution
def fitFunc(self, x, p):
from labrad import units as U
flop = te.time_evolution(trap_frequency=U.WithUnit(p[4], 'MHz'),
projection=p[7],
sideband_order=p[5],
nmax=p[6])
evolution = flop.state_evolution_fluc(x * 10**-6,
p[0],
p[1],
p[2],
p[3],
n_fluc=5.0)
return evolution
def setRabiFrequencyFromPiTime(self,twopitime):
if self.curveName == 'Rabi Flop':
# create reasonable guess for rabi frequency based on sideband, trap_frequency
trap_frequency=self.parent.savedAnalysisParameters[self.dataset, self.directory, self.index, 'Rabi Flop'][0]['Trap Frequency']
sideband_order=self.parent.savedAnalysisParameters[self.dataset, self.directory, self.index, 'Rabi Flop'][0]['Sideband']
nmax=self.parent.savedAnalysisParameters[self.dataset, self.directory, self.index, 'Rabi Flop'][0]['nmax']
# call time evolution via fitRabiflop to get lamb-dicke parameter
import timeevolution as te
from labrad import units as U
eta=te.time_evolution(U.WithUnit(trap_frequency,'MHz'),sideband_order,nmax).eta
self.parent.savedAnalysisParameters[self.dataset, self.directory, self.index, self.curveName][0]['Rabi Frequency']=1.0/((2.0*eta)**np.abs(sideband_order)*twopitime*10**-6)
self.fitCurves(parameters = self.getParameter(),drawCurves = True)
self.onActivated()
def model(self, params, x):
nbar = params['nbar'].value
f_rabi = params['f_rabi'].value
delta = params['delta'].value
delta_fluct = params['delta_fluctuations'].value
trap_freq = params['trap_freq'].value
sideband = params['sideband'].value
nmax = params['nmax'].value
projection = params['projection'].value
flop = te.time_evolution(trap_frequency = U.WithUnit(trap_freq, 'MHz'), projection = projection,
sideband_order = sideband, nmax = nmax)
evolution = flop.state_evolution_fluc(x*10**-6, nbar, f_rabi, delta, delta_fluct, n_fluc = 5.0 )
return evolution
def setRabiFrequencyFromPiTime(self, twopitime):
if self.curveName == 'Rabi Flop':
# create reasonable guess for rabi frequency based on sideband, trap_frequency
trap_frequency = self.parent.savedAnalysisParameters[
self.dataset, self.directory, self.index,
'Rabi Flop'][0]['Trap Frequency']
sideband_order = self.parent.savedAnalysisParameters[
self.dataset, self.directory, self.index,
'Rabi Flop'][0]['Sideband']
nmax = self.parent.savedAnalysisParameters[self.dataset,
self.directory,
self.index,
'Rabi Flop'][0]['nmax']
# call time evolution via fitRabiflop to get lamb-dicke parameter
import timeevolution as te
from labrad import units as U
eta = te.time_evolution(U.WithUnit(trap_frequency, 'MHz'),
sideband_order, nmax).eta
self.parent.savedAnalysisParameters[
self.dataset, self.directory, self.index,
self.curveName][0]['Rabi Frequency'] = 1.0 / (
(2.0 * eta)**np.abs(sideband_order) * twopitime * 10**-6)
self.fitCurves(parameters=self.getParameter(), drawCurves=True)
self.onActivated()
# take list of evolutions with differnet phases and average --> dephasing!
dv.cd(dephase_directory)
deph_y_axis_list = []
for i in dephase_numbers:
dv.cd(dephase_files[i])
dv.open(1)
data = dv.get().asarray
deph_y_axis_list.append(data[:, 1])
dv.cd(1)
deph_y_axis = np.sum(deph_y_axis_list, axis=0) / np.float32(len(dephase_files))
deph_x_axis = data[:, 0] * 10**(-6) + dephasing_time_offset['s']
t0 = deph_x_axis.min() + dephasing_time_offset['s']
#fit Rabi Flops to theory
evo = tp.time_evolution(trap_frequency, sideband, nmax=amax)
def f(x):
evolution = evo.state_evolution_fluc(x, nb(), f_Rabi(), delta(),
delta_fluc())
return evolution
eta = evo.eta
fitting_region = np.where((flop_x_axis >= fit_range_min['s'])
& (flop_x_axis <= fit_range_max['s']))
flop_errors = np.sqrt(flop_y_axis * (1 - flop_y_axis) /
(100.0 * len(flop_files)))
print 'Fitting...'
# take list of evolutions with differnet phases and average --> dephasing!
dv.cd(dephase_directory)
deph_y_axis_list=[]
for i in dephase_numbers:
dv.cd(dephase_files[i])
dv.open(1)
data = dv.get().asarray
deph_y_axis_list.append(data[:,1])
dv.cd(1)
deph_y_axis = np.sum(deph_y_axis_list,axis=0)/np.float32(len(dephase_files))
deph_x_axis=data[:,0]*10**(-6)+dephasing_time_offset['s']
t0 = deph_x_axis.min()+dephasing_time_offset['s']
#fit Rabi Flops to theory
evo=tp.time_evolution(trap_frequency, sideband,nmax = amax)
def f(x):
evolution = evo.state_evolution_fluc(x,nb(),f_Rabi(),delta(),delta_fluc())
return evolution
eta = evo.eta
fitting_region = np.where((flop_x_axis >= fit_range_min['s'])&(flop_x_axis <= fit_range_max['s']))
flop_errors = np.sqrt(flop_y_axis*(1-flop_y_axis)/(100.0*len(flop_files)))
print 'Fitting...'
p,cov,infodict,mesg,success = fit(f, fit_params, y = flop_y_axis[fitting_region], yerr=flop_errors[fitting_region],x = flop_x_axis[fitting_region])
print 'Fitting DONE.'
#print "nbar = {}".format(nb())
#print "Rabi Frequency = {} kHz".format(f_Rabi()*10**(-3))
print "The detuning fluctuates around ({:.2f} with a spread of {:.2f}) kHz".format(delta()*10**-3,np.abs(delta_fluc())*10**-3)
dv.cd(dephase_directory)
deph_y_axis_list=[]
for i in dephase_numbers:
dv.cd(dephase_files[i])
dv.open(1)
data = dv.get().asarray
deph_y_axis_list.append(data[:,1])
dv.cd(1)
deph_y_axis = np.sum(deph_y_axis_list,axis=0)/np.float32(len(dephase_files))
deph_x_axis=data[:,0]*10**(-6)+dephasing_time_offset['s']
t0 = deph_x_axis.min()+dephasing_time_offset['s']
#fit to theory
evo=te.time_evolution(trap_frequency, sideband,nmax = 1000)
def f(x):
evolution = evo.state_evolution_fluc(x,nb(),f_Rabi(),delta(),delta_fluc())
return evolution
fitting_region = np.where((flop_x_axis >= fit_range_min['s'])&(flop_x_axis <= fit_range_max['s']))
print 'Fitting...'
p,success = fit(f, fit_params, y = flop_y_axis[fitting_region], x = flop_x_axis[fitting_region])
print 'Fitting DONE.'
figure = pyplot.figure()
print "nbar = {}".format(nb())
print "Rabi Frequency = {} kHz".format(f_Rabi()*10**(-3))
print "The detuning is centered around {} kHz and spreads with a variance of {} kHz".format(delta()*10**-3,np.abs(delta_fluc())*10**-3)
# take list of evolutions with differnet phases and average --> dephasing!
dv.cd(dephase_directory)
deph_y_axis_list = []
for i in dephase_numbers:
dv.cd(dephase_files[i])
dv.open(1)
data = dv.get().asarray
deph_y_axis_list.append(data[:, 1])
dv.cd(1)
deph_y_axis = np.sum(deph_y_axis_list, axis=0) / np.float32(len(dephase_files))
deph_x_axis = data[:, 0] * 10**(-6) + dephasing_time_offset['s']
t0 = deph_x_axis.min() + dephasing_time_offset['s']
#fit to theory
evo = te.time_evolution(trap_frequency, sideband, nmax=1000)
def f(x):
evolution = evo.state_evolution_fluc(x, nb(), f_Rabi(), delta(),
delta_fluc())
return evolution
fitting_region = np.where((flop_x_axis >= fit_range_min['s'])
& (flop_x_axis <= fit_range_max['s']))
print 'Fitting...'
p, success = fit(f,
fit_params,
y=flop_y_axis[fitting_region],
x=flop_x_axis[fitting_region])
def get_nbar(flop_directory,
blue_file,
red_file,
fit_until=U.WithUnit(1000.0, 'us'),
show=False):
print 'obtaining nbar from peak ratio of red and blue flop ...',
#parameters and initial guesses for fit
sideband = 1.0
amax = 2000.0
f_Rabi_init = U.WithUnit(150.0, 'kHz')
nb_init = 0.1
delta_init = U.WithUnit(1000.0, 'Hz')
fit_range_min = U.WithUnit(0.0, 'us')
fit_range_max = fit_until
delta_fluc_init = U.WithUnit(100.0, 'Hz')
#actual script starts here
class Parameter:
def __init__(self, value):
self.value = value
def set(self, value):
self.value = value
def __call__(self):
return self.value
def fit(function, parameters, y, x=None):
def f(params):
i = 0
for p in parameters:
p.set(params[i])
i += 1
return y - function(x)
if x is None: x = np.arange(y.shape[0])
p = [param() for param in parameters]
return optimize.leastsq(f, p)
#get access to servers
cxn = labrad.connect('192.168.169.197', password='******')
dv = cxn.data_vault
#get trap frequency
dv.cd(flop_directory)
dv.cd(blue_file)
dv.open(1)
sideband_selection = dv.get_parameter('RabiFlopping.sideband_selection')
sb = np.array(sideband_selection)
trap_frequencies = [
'TrapFrequencies.radial_frequency_1',
'TrapFrequencies.radial_frequency_2',
'TrapFrequencies.axial_frequency', 'TrapFrequencies.rf_drive_frequency'
]
trap_frequency = dv.get_parameter(
str(np.array(trap_frequencies)[sb.nonzero()][0]))
#SET PARAMETERS
nb = Parameter(nb_init)
f_Rabi = Parameter(f_Rabi_init['Hz'])
delta = Parameter(delta_init['Hz'])
delta_fluc = Parameter(delta_fluc_init['Hz'])
#which to fit?
fit_params = [nb, f_Rabi, delta, delta_fluc]
# take Rabi flops
data = dv.get().asarray
blue_flop_y_axis = data[:, 1]
blue_flop_x_axis = data[:, 0] * 10**(-6)
dv.cd(1)
dv.cd(red_file)
dv.open(1)
data = dv.get().asarray
red_flop_y_axis = data[:, 1]
red_flop_x_axis = data[:, 0] * 10**(-6)
#fit Rabi Flops to theory
blue_evo = tp.time_evolution(trap_frequency, sideband, nmax=amax)
def blue_f(x):
evolution = blue_evo.state_evolution_fluc(x, nb(), f_Rabi(), delta(),
delta_fluc())
return evolution
red_evo = tp.time_evolution(trap_frequency, -sideband, nmax=amax)
def red_f(x):
evolution = red_evo.state_evolution_fluc(x, nb(), f_Rabi(), delta(),
delta_fluc())
return evolution
#FIT BLUE
fitting_region = np.where((blue_flop_x_axis >= fit_range_min['s'])
& (blue_flop_x_axis <= fit_range_max['s']))
fit(blue_f,
fit_params,
y=blue_flop_y_axis[fitting_region],
x=blue_flop_x_axis[fitting_region])
blue_nicer_resolution = np.linspace(0, blue_flop_x_axis.max(), 1000)
blue_flop_fit_y_axis = blue_evo.state_evolution_fluc(
blue_nicer_resolution, nb(), f_Rabi(), delta(), delta_fluc())
m = pylab.unravel_index(
np.array(blue_flop_fit_y_axis).argmax(),
np.array(blue_flop_fit_y_axis).shape)
blue_max = np.array(blue_flop_fit_y_axis).max()
fit_params = [nb, delta, delta_fluc]
#FIT RED
fitting_region = np.where((red_flop_x_axis >= fit_range_min['s'])
& (red_flop_x_axis <= fit_range_max['s']))
fit(red_f,
fit_params,
y=red_flop_y_axis[fitting_region],
x=red_flop_x_axis[fitting_region])
red_nicer_resolution = np.linspace(0, red_flop_x_axis.max(), 1000)
red_flop_fit_y_axis = red_evo.state_evolution_fluc(red_nicer_resolution,
nb(), f_Rabi(), delta(),
delta_fluc())
red_max = red_flop_fit_y_axis[m]
r = red_max / blue_max
ratio_nbar = r / (1 - r)
if show:
size = 0.8
figure = pyplot.figure()
pyplot.plot(blue_nicer_resolution * 10**6, blue_flop_fit_y_axis, 'b-')
yerrflop = np.sqrt((1 - blue_flop_y_axis) * blue_flop_y_axis / (100.0))
pyplot.errorbar(blue_flop_x_axis * 10**6,
blue_flop_y_axis,
yerrflop,
xerr=0,
fmt='bo')
pyplot.xlabel(r'Evolution time in $\mu s$', fontsize=size * 22)
pyplot.ylim((0, 1))
pyplot.ylabel('Local Hilbert-Schmidt Distance', fontsize=size * 22)
#pyplot.legend()
pyplot.plot(red_nicer_resolution * 10**6, red_flop_fit_y_axis, 'r-')
yerrflop = np.sqrt((1 - red_flop_y_axis) * red_flop_y_axis / (100.0))
pyplot.errorbar(red_flop_x_axis * 10**6,
red_flop_y_axis,
yerrflop,
xerr=0,
fmt='ro')
pyplot.text(
blue_flop_x_axis.max() * 0.70 * 10**6, 0.80,
'nbar (from ratio at blue peak) = {:.2f}'.format(ratio_nbar))
pyplot.tick_params(axis='x', labelsize=size * 20)
pyplot.tick_params(axis='y', labelsize=size * 20)
pyplot.show()
print 'done.'
return ratio_nbar
if 'fit_from' in info:
fit_from = info['fit_from']['s']
else:
fit_from = tmin
fitting_region = np.where((times <= fit_until) & (times >= fit_from))
fit_times = detailed_times - offset_time
# Find out what data and fit
if info['plot_type'] == 'rabi_flop':
if 'sideband' in info: sideband_order = info['sideband']
else: sideband_order = 0
if 'nmax' in info: nmax = info['nmax']
else: nmax = 1000
trap_frequency = info['trap_frequency']
flop = te.time_evolution(nmax=nmax,
trap_frequency=trap_frequency,
sideband_order=sideband_order)
if 'take_init_fRabi_from_Pi_time' in info:
fit_init_fRabi = 1.0 / (
(2.0 * flop.eta)**np.abs(sideband_order) * 2.0 *
info['take_init_fRabi_from_Pi_time']['s'])
else:
fit_init_fRabi = info['fit_init_fRabi']['Hz']
fit_init_nbar = info['fit_init_nbar']
fit_init_delta = info['fit_init_delta']['Hz']
fit_init_delta_fluc = info['fit_init_delta_fluc']['Hz']
nbar = Parameter(info['fit_init_nbar'])
delta = Parameter(fit_init_delta)
delta_fluc = Parameter(fit_init_delta_fluc)
f_Rabi = Parameter(fit_init_fRabi)
fit_until=tmax
if 'fit_from' in info:
fit_from=info['fit_from']['s']
else:
fit_from=tmin
fitting_region = np.where((times <= fit_until) & (times>=fit_from))
fit_times = detailed_times - offset_time
# Find out what data and fit
if info['plot_type']=='rabi_flop':
if 'sideband' in info: sideband_order=info['sideband']
else: sideband_order=0
if 'nmax' in info: nmax=info['nmax']
else: nmax=1000
trap_frequency = info['trap_frequency']
flop = te.time_evolution(nmax=nmax,trap_frequency = trap_frequency, sideband_order = sideband_order)
if 'take_init_fRabi_from_Pi_time' in info: fit_init_fRabi=1.0/((2.0*flop.eta)**np.abs(sideband_order)*2.0*info['take_init_fRabi_from_Pi_time']['s'])
else: fit_init_fRabi=info['fit_init_fRabi']['Hz']
fit_init_nbar=info['fit_init_nbar']
fit_init_delta=info['fit_init_delta']['Hz']
fit_init_delta_fluc=info['fit_init_delta_fluc']['Hz']
nbar = Parameter(info['fit_init_nbar'])
delta = Parameter(fit_init_delta)
delta_fluc = Parameter(fit_init_delta_fluc)
f_Rabi = Parameter(fit_init_fRabi)
def f(t):
evolution = flop.state_evolution_fluc(t,nbar(), f_Rabi(), delta(), delta_fluc())
return evolution
fit_params=[]
if info['fit_fRabi']: fit_params.append(f_Rabi)
if info['fit_nbar']: fit_params.append(nbar)
import timeevolution as te
from matplotlib import pyplot
import numpy as np
from labrad import units as U
tmin = 0
tmax = 0.001
t = np.linspace(tmin, tmax, 1000)
evo = te.time_evolution(U.WithUnit(2.8, 'MHz'), 1)
omega = 180000
nbar = 0.626127382989
#evo.state_evolution(t, 5.0, 20000)
nminusone = evo.n - 1
nminusone[0] = 0
omeganminusone = evo.effective_rabi_coupling(nminusone) * omega
omeganminusone[0] = 0
omegan = evo.rabi_coupling * omega
p = evo.p_thermal(nbar, nshift=False)
ones = np.ones_like(t)
flop = evo.state_evolution(t, nbar, omega / (2.0 * np.pi))
gg = 0.5 * np.sum(np.outer(p, ones) *
(np.cos(np.outer(omegan / 2.0, t))**2 +
np.sin(np.outer(omeganminusone / 2.0, t))**2),
axis=0)
eg = -0.5 * 1.j * np.sum(
np.outer(p, ones) * np.cos(np.outer(omeganminusone / 2.0, t)) *
(np.cos(np.outer(omegan / 2.0, t)) -
1.j * np.sin(np.outer(omeganminusone / 2.0, t))),
def get_nbar(flop_directory,blue_file,red_file,fit_until=U.WithUnit(1000.0,'us'),show=False):
print 'obtaining nbar from peak ratio of red and blue flop ...',
#parameters and initial guesses for fit
sideband = 1.0
amax=2000.0
f_Rabi_init = U.WithUnit(150.0,'kHz')
nb_init = 0.1
delta_init = U.WithUnit(1000.0,'Hz')
fit_range_min=U.WithUnit(0.0,'us')
fit_range_max=fit_until
delta_fluc_init=U.WithUnit(100.0,'Hz')
#actual script starts here
class Parameter:
def __init__(self, value):
self.value = value
def set(self, value):
self.value = value
def __call__(self):
return self.value
def fit(function, parameters, y, x = None):
def f(params):
i = 0
for p in parameters:
p.set(params[i])
i += 1
return y - function(x)
if x is None: x = np.arange(y.shape[0])
p = [param() for param in parameters]
return optimize.leastsq(f, p)
#get access to servers
cxn = labrad.connect('192.168.169.197', password = '******')
dv = cxn.data_vault
#get trap frequency
dv.cd(flop_directory)
dv.cd(blue_file)
dv.open(1)
sideband_selection = dv.get_parameter('RabiFlopping.sideband_selection')
sb = np.array(sideband_selection)
trap_frequencies = ['TrapFrequencies.radial_frequency_1','TrapFrequencies.radial_frequency_2','TrapFrequencies.axial_frequency','TrapFrequencies.rf_drive_frequency']
trap_frequency = dv.get_parameter(str(np.array(trap_frequencies)[sb.nonzero()][0]))
#SET PARAMETERS
nb = Parameter(nb_init)
f_Rabi = Parameter(f_Rabi_init['Hz'])
delta = Parameter(delta_init['Hz'])
delta_fluc=Parameter(delta_fluc_init['Hz'])
#which to fit?
fit_params = [nb,f_Rabi,delta,delta_fluc]
# take Rabi flops
data = dv.get().asarray
blue_flop_y_axis = data[:,1]
blue_flop_x_axis = data[:,0]*10**(-6)
dv.cd(1)
dv.cd(red_file)
dv.open(1)
data = dv.get().asarray
red_flop_y_axis = data[:,1]
red_flop_x_axis = data[:,0]*10**(-6)
#fit Rabi Flops to theory
blue_evo=tp.time_evolution(trap_frequency, sideband,nmax = amax)
def blue_f(x):
evolution = blue_evo.state_evolution_fluc(x,nb(),f_Rabi(),delta(),delta_fluc())
return evolution
red_evo=tp.time_evolution(trap_frequency, -sideband,nmax = amax)
def red_f(x):
evolution = red_evo.state_evolution_fluc(x,nb(),f_Rabi(),delta(),delta_fluc())
return evolution
#FIT BLUE
fitting_region = np.where((blue_flop_x_axis >= fit_range_min['s'])&(blue_flop_x_axis <= fit_range_max['s']))
fit(blue_f, fit_params, y = blue_flop_y_axis[fitting_region], x = blue_flop_x_axis[fitting_region])
blue_nicer_resolution = np.linspace(0,blue_flop_x_axis.max(),1000)
blue_flop_fit_y_axis = blue_evo.state_evolution_fluc(blue_nicer_resolution, nb(), f_Rabi(), delta(),delta_fluc())
m=pylab.unravel_index(np.array(blue_flop_fit_y_axis).argmax(), np.array(blue_flop_fit_y_axis).shape)
blue_max = np.array(blue_flop_fit_y_axis).max()
fit_params = [nb,delta,delta_fluc]
#FIT RED
fitting_region = np.where((red_flop_x_axis >= fit_range_min['s'])&(red_flop_x_axis <= fit_range_max['s']))
fit(red_f, fit_params, y = red_flop_y_axis[fitting_region], x = red_flop_x_axis[fitting_region])
red_nicer_resolution = np.linspace(0,red_flop_x_axis.max(),1000)
red_flop_fit_y_axis = red_evo.state_evolution_fluc(red_nicer_resolution, nb(), f_Rabi(), delta(),delta_fluc())
red_max = red_flop_fit_y_axis[m]
r = red_max/blue_max
ratio_nbar = r/(1-r)
if show:
size=0.8
figure = pyplot.figure()
pyplot.plot(blue_nicer_resolution*10**6,blue_flop_fit_y_axis,'b-')
yerrflop = np.sqrt((1-blue_flop_y_axis)*blue_flop_y_axis/(100.0))
pyplot.errorbar(blue_flop_x_axis*10**6, blue_flop_y_axis, yerrflop, xerr = 0, fmt='bo')
pyplot.xlabel(r'Evolution time in $\mu s$',fontsize=size*22)
pyplot.ylim((0,1))
pyplot.ylabel('Local Hilbert-Schmidt Distance',fontsize=size*22)
#pyplot.legend()
pyplot.plot(red_nicer_resolution*10**6,red_flop_fit_y_axis,'r-')
yerrflop = np.sqrt((1-red_flop_y_axis)*red_flop_y_axis/(100.0))
pyplot.errorbar(red_flop_x_axis*10**6, red_flop_y_axis, yerrflop, xerr = 0, fmt='ro')
pyplot.text(blue_flop_x_axis.max()*0.70*10**6,0.80, 'nbar (from ratio at blue peak) = {:.2f}'.format(ratio_nbar))
pyplot.tick_params(axis='x', labelsize=size*20)
pyplot.tick_params(axis='y', labelsize=size*20)
pyplot.show()
print 'done.'
return ratio_nbar
import timeevolution as te from matplotlib import pyplot import numpy as np from labrad import units as U tmin = 0 tmax = 0.001 t=np.linspace(tmin,tmax,1000) evo = te.time_evolution(U.WithUnit(2.8,'MHz'), 1) omega = 180000 nbar = 0.626127382989 #evo.state_evolution(t, 5.0, 20000) nminusone = evo.n-1 nminusone[0]=0 omeganminusone = evo.effective_rabi_coupling(nminusone)*omega omeganminusone[0]=0 omegan = evo.rabi_coupling*omega p=evo.p_thermal(nbar,nshift = False) ones = np.ones_like(t) flop = evo.state_evolution(t, nbar, omega/(2.0*np.pi)) gg = 0.5*np.sum(np.outer(p,ones)*(np.cos(np.outer(omegan/2.0,t))**2+np.sin(np.outer(omeganminusone/2.0,t))**2),axis=0) eg = -0.5*1.j*np.sum(np.outer(p,ones)*np.cos(np.outer(omeganminusone/2.0,t))*(np.cos(np.outer(omegan/2.0,t))-1.j*np.sin(np.outer(omeganminusone/2.0,t))),axis=0) ee = 1-np.abs(gg) egreal = np.real(eg) egim = np.imag(eg) figure = pyplot.figure()
