def Plot(self, File=None, xlim=None, fit=False):
fig = pylab.figure(figsize=(10, 6))
N, Bins = self.Hist(self._Trace)
ax = fig.add_subplot(121)
ax.bar(Bins, N, align='center')
if fit:
FitParameters = Fit.Fit(Bins, N, Fit.DoubleGaussian,
Fit.DoubleGaussianEstimator)
ax.plot(Bins, Fit.DoubleGaussian(*FitParameters)(Bins))
ax.axvline(self._Threshold, color='red', linestyle='-')
ax.axvline(0.5 * (FitParameters[2] + FitParameters[3]),
color='green',
linestyle='--')
if xlim is not None:
ax.set_xlim(xlim)
ax.set_title('unfiltered')
ax = fig.add_subplot(122)
N, Bins = self.Hist(self._FilteredTrace)
ax.bar(Bins, N, align='center')
if fit:
FitParameters = Fit.Fit(Bins, N, Fit.DoubleGaussian,
Fit.DoubleGaussianEstimator)
ax.plot(Bins, Fit.DoubleGaussian(*FitParameters)(Bins))
ax.axvline(self._Threshold, color='red', linestyle='-')
ax.axvline(0.5 * (FitParameters[2] + FitParameters[3]),
color='green',
linestyle='--')
if xlim is not None:
ax.set_xlim(xlim)
ax.set_title('conditional')
if File is None:
fig.show()
else:
fig.savefig(File)
return fig
def rabi_fit(self, rabi_x, rabi_y):
x = rabi_x
y = rabi_y
x = np.array(x)
y = np.array(y)
y_offset = y.mean()
yreal = y - y_offset
try:
fit_parameters = Fit.Fit(x, yreal, Fit.CosinusNoOffset,
Fit.CosinusNoOffsetEstimator)
except:
print 'Error'
return None
if fit_parameters[0] < 0:
fit_parameters[0] = -fit_parameters[0]
fit_parameters[2] = (
(fit_parameters[2] / fit_parameters[1] + 0.5) %
1) * fit_parameters[1]
fit_parameters = Fit.Fit(x, yreal, Fit.CosinusNoOffset,
fit_parameters)
fit_parameters = (fit_parameters[0], fit_parameters[1],
fit_parameters[2], y_offset)
fit_parameters = Fit.Fit(x, y, Fit.Cosinus, fit_parameters)
while (fit_parameters[2] > 0.5 * fit_parameters[1]):
fit_parameters[2] -= fit_parameters[1]
fit_parameters = Fit.Fit(x, y, Fit.Cosinus, fit_parameters)
fit_parameters = list(fit_parameters)
fit_parameters.append(10 * max(x))
fit_parameters = Fit.Fit(x, y, Fit.Cosinus_dec, fit_parameters)
return fit_parameters
def Minima(self, fit=False, Bins=20):
x = self.x
y = self.y
N, B = numpy.histogram(y, Bins)
High = B[N.argmax()]
Low = y.min()
c = 0.5 * (High + Low)
dips = y < c
edges = numpy.flatnonzero(dips[:-1] ^ dips[1:])
edges = edges.reshape((len(edges) / 2, 2))
minpos = []
minval = []
for fall, rise in edges:
i = fall + y[fall:rise].argmin()
minpos.append(x[i])
minval.append(y[i])
if fit == True:
p = Fit.Fit(self.x, self.y, Fit.TripleLorentzian,
(minpos[0], minpos[1], minpos[2], 1e6, 1e6, 1e6,
minval[0] - c, minval[1] - c, minval[2] - c, c))
minpos = p[:3]
return numpy.array(minpos)
def _Calculate_depth_fired(self):
# take the values from the calculated spectral density
nu = np.array(self.nu)
spectrum_y = np.array(self.spectrum_y)
spectrum_yy = np.array(self.spectrum_yy)
nu_calc = nu[np.logical_and(nu >= self.spec_min, nu <= self.spec_max)]
spectrum_y_calc = []
spectrum_yy_calc = []
i = 0
for i in range(0, len(nu)):
if nu[i] in nu_calc:
spectrum_y_calc.append(spectrum_y[i])
if spectrum_yy != []:
spectrum_yy_calc.append(spectrum_yy[i])
# performing lorentzian fits to the spectral data
spectrum_y_calc = np.array(spectrum_y_calc)
self.lorentz_fit_parameters_y = Fit.Fit(nu_calc, spectrum_y_calc,
Fit.Lorentzian,
Fit.LorentzianEstimator)
self.density_plot_fit_y = Fit.Lorentzian(
*self.lorentz_fit_parameters_y)(nu)
if spectrum_yy != []:
spectrum_yy_calc = np.array(spectrum_yy_calc)
self.lorentz_fit_parameters_yy = Fit.Fit(nu_calc, spectrum_yy_calc,
Fit.Lorentzian,
Fit.LorentzianEstimator)
self.density_plot_fit_yy = Fit.Lorentzian(
*self.lorentz_fit_parameters_yy)(nu)
# update the spectral density plots with the fits in it
self._plot_density_changed(nu, spectrum_y, spectrum_yy)
# calculate the area from the lorentz fit
gamma_e = self.gamma_e
rho = self.proton_density * 1e27 #to get 1/m^3
Area1 = self.lorentz_fit_parameters_y[2] #in MHz^2
print Area1
#Area1 = 0.0721
B1 = abs(2 * Area1 / (gamma_e * gamma_e))**(0.5) #in Tesla
self.depth1 = Calculate.calculate_depth_simple(B1, rho)
print B1
if spectrum_yy != []:
Area2 = self.lorentz_fit_parameters_yy[2] #in MHz^2
print Area2
B2 = abs(2 * Area2 / (gamma_e * gamma_e))**(0.5) #in Tesla
self.depth2 = Calculate.calculate_depth_simple(B2, rho)
print B2
def Fit(self):
if not hasattr(self, 'Normal'):
self.Analyze()
p = Fit.Fit(self.RFTau, self.BinaryFiltered, Fit.Cosinus,
Fit.CosinusEstimator)
# if p[1] < 0:
# p[1] = -p[1]
# p[-1] = ( ( p[-1]/p[-2] + 0.5 ) % 1 ) * p[-2]
# p = Fit.Fit(self.RFTau, self.BinaryFiltered, Fit.Cosinus, p)
# if p[-1] / p[-2] < 0:
# p[-1] = (p[-1] / p[-2] + 1) * p[-2]
# p = Fit.Fit(self.RFTau, self.BinaryFiltered, Fit.Cosinus, p)
self.FitParameters = p
self.RabiMean = p[0]
self.RabiAmpl = p[1]
self.RabiPeriod = p[2]
self.Rabix0 = p[3]
