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 fit(self,initialGuess,qData,numberOfChi=None,stddev=None,peakList=None):
if (numberOfChi==None and peakList==None):
raise Exception("Cannot fit the calibration data unless either the number of chi values or a peak list are given.")
# make peak list
if peakList == None:
peakList = Fit.getPeakList(self.theDiffractionData.data,qData,
initialGuess,numberOfChi,stddev)
# do fitting
return Fit.fit(self.theDiffractionData.data,
initialGuess,peakList)
def savePeakListToFile(self,filename,initialGuess,qData,
numberOfChi,maskedPixelInfo,stddev):
peakList = Fit.getPeakList(self.theDiffractionData.data,qData,
initialGuess,numberOfChi,stddev)
# now, save to file
file = open(filename,"w")
file.write("# A list of diffraction peaks found.\n")
file.write("# Diffraction Data: %s\n" % self.theDiffractionData.filename)
file.write("# Calculated on "+time.asctime()+"\n")
file.write("# Calibration data used to find peaks:\n")
initialGuess.writeCommentString(file)
file.write("# Q data used to find peaks:\n")
file.write("# Peaks:\n")
qData.writeCommentString(file)
if maskedPixelInfo.doPolygonMask and maskedPixelInfo.numPolygons() > 0:
file.write("# All peaks inside of polygon mask(s) were ignored.\n")
file.write(maskedPixelInfo.writePolygonCommentString())
file.write("#%16s%21s%21s%21s%21s%21s%21s%21s\n" % \
("x","y","Real Q","Fit Q","chi","width","intensity","2theta"))
for peak in peakList.getMaskedPeakList(maskedPixelInfo):
x,y,realQ,fitQ,chi,width = peak
intensity=self.getPixelValueBilinearInterpolation(x,y)
twoTheta = Transform.convertQToTwoTheta(fitQ,initialGuess)
file.write("%17.10f %17.10f %17.10f %17.10f %17.10f %17.10f %17.10f %17.10f\n" % \
(x,y,realQ,fitQ,chi,width,intensity,twoTheta) )
file.close()
return peakList
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 plotData(self, linear=True):
if (linear):
plt.plot(self.linearVoltage, self.originalCurrent, color='y')
plt.plot(self.linearVoltage, fit.polyFit(self.linearVoltage, self.originalCurrent, 6), 'g--', linewidth=0.5)
print("Linearized Voltage")
else:
plt.plot(self.originalVoltage, self.originalCurrent)
print("Non-linearized Voltage")
def fit(self,
initialGuess,
qData,
numberOfChi=None,
stddev=None,
peakList=None):
if (numberOfChi == None and peakList == None):
raise Exception(
"Cannot fit the calibration data unless either the number of chi values or a peak list are given."
)
# make peak list
if peakList == None:
peakList = Fit.getPeakList(self.theDiffractionData.data, qData,
initialGuess, numberOfChi, stddev)
# do fitting
return Fit.fit(self.theDiffractionData.data, initialGuess, peakList)
def savePeakListToFile(self,filename,initialGuess,qData,numberOfChi,stddev):
peakList = Fit.getPeakList(self.theDiffractionData.data,qData,
initialGuess,numberOfChi,stddev)
# now, save to file
file = open(filename,'w')
file.write("# A list of peaks found in the diffraction image.\n")
file.write("# Calculated on "+time.asctime()+"\n")
file.write("# Calibration data used to find peaks:\n")
initialGuess.writeCommentString(file)
file.write("#\tx\ty\tRealQ\tFitQ\tchi\twidth\tintensity\t2theta\n")
for peak in peakList:
x,y,realQ,fitQ,chi,width = peak
intensity=self.getPixelValueBilinearInterpolation(x,y)
twoTheta = Transform.convertQToTwoTheta(fitQ,initialGuess)
file.write("%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n" % \
(x,y,realQ,fitQ,chi,width,intensity,twoTheta) )
file.close()
return peakList
def plotLogExtension(self):
coef = fit.getCoef([1,2],[self.logFit[-1], self.logFit[-2]], 1)
def getLogFit(self):
ll = self.lowerLogLimit
ul = self.upperLogLimit
return fit.logFit(self.linearVoltage[ll:ul], self.originalCurrent[ll:ul])
def getLinearVoltage(self):
if (self.originalVoltage == None):
print("hi")
return fit.lineFit(np.arange(len(self.originalVoltage)), self.originalVoltage)
def fit(self,initialGuess,qData,maskedPixelInfo,
numberOfChi=None,stddev=None,peakList=None):
if (numberOfChi==None and peakList==None):
raise Exception("Cannot fit the calibration data \
unless either the number of chi values or a peak list are given.")
# make peak list
print
print "Finding diffraction peaks..."
if peakList == None:
peakList = Fit.getPeakList(self.theDiffractionData.data,qData,
initialGuess,numberOfChi,stddev)
print
print "Performing image calibration..."
# do fitting
bestGuess,peakList,covariance,initialResidual,finalResidual, \
reasonForQuitting = Fit.fit(self.theDiffractionData.data,
initialGuess,peakList,maskedPixelInfo)
print " - Before fitting, the calculated residual \
per peak is ",initialResidual
print " - After fitting, the calculated residual \
per peak is ",finalResidual
print " - Reason for quitting the fit: %d, " % reasonForQuitting,
if reasonForQuitting == 2:
print "stopped by small gradient J^T e\n"
elif reasonForQuitting == 2:
print "stopped by small Dp\n"
elif reasonForQuitting == 3:
print "stopped by itmax\n"
elif reasonForQuitting == 4:
print "singular matrix. Restart from current p with increased \\mu\n"
elif reasonForQuitting == 5:
print "no further error reduction is possible. Restart with increased mu\n"
elif reasonForQuitting == 6:
print "stopped by small ||e||_2\n"
else:
print "Reason for quitting unknown\n"
print "Covariance Matrix:"
print Numeric.array2string(covariance,max_line_width=1000,precision=3)
print
print "Root of the diagonal of the covariance matrix (I think these are uncertainties)"
print " - xc %17.10f" % sqrt(covariance[0][0])
print " - yc %17.10f" % sqrt(covariance[1][1])
print " - d %17.10f" % sqrt(covariance[2][2])
print " - E %17.10f" % sqrt(covariance[3][3])
print " - alpha %17.10f" % sqrt(covariance[4][4])
print " - beta %17.10f" % sqrt(covariance[5][5])
print " - R %17.10f" % sqrt(covariance[6][6])
# create the string to save to a file (if requested)
self.lastFitString = ""
self.lastFitString += "Fit done of: %s\n" % self.theDiffractionData.filename
self.lastFitString += "\n"
self.lastFitString += "Initial Guess at calibration parameters:\n"
self.lastFitString += str(initialGuess)
self.lastFitString += "\n"
self.lastFitString += "Before fitting, the calculated residual \
per peak is "+str(initialResidual)+"\n"
self.lastFitString += "\n"
self.lastFitString += "Refined calibration parameters:\n"
self.lastFitString += str(bestGuess)
self.lastFitString += "\n"
self.lastFitString += "After fitting, the calculated residual \
per peak is "+str(finalResidual)+"\n"
self.lastFitString += "\n"
self.lastFitString += "Reason for quitting the fit: %d-" % reasonForQuitting
if reasonForQuitting == 2:
self.lastFitString += "stopped by small gradient J^T e\n"
elif reasonForQuitting == 2:
self.lastFitString += "stopped by small Dp\n"
elif reasonForQuitting == 3:
self.lastFitString += "stopped by itmax\n"
elif reasonForQuitting == 4:
self.lastFitString += "singular matrix. Restart from current p with increased \\mu\n"
elif reasonForQuitting == 5:
self.lastFitString += "no further error reduction is possible. Restart with increased mu\n"
elif reasonForQuitting == 6:
self.lastFitString += "stopped by small ||e||_2\n"
else:
self.lastFitString += "Reason for quitting unknown\n"
self.lastFitString += "\n"
self.lastFitString += "Covariance Matrix:\n"
self.lastFitString += "%s\n" % Numeric.array2string(covariance,
max_line_width=1000,precision=10)
self.lastFitString += "\n"
self.lastFitString += "Root of the diagonal of the \
covariance matrix (I think these are uncertainties)\n"
self.lastFitString += "xc %17.10f\n" % sqrt(covariance[0][0])
self.lastFitString += "yc %17.10f\n" % sqrt(covariance[1][1])
self.lastFitString += "d %17.10f\n" % sqrt(covariance[2][2])
self.lastFitString += "E %17.10f\n" % sqrt(covariance[3][3])
self.lastFitString += "alpha %17.10f\n" % sqrt(covariance[4][4])
self.lastFitString += "beta %17.10f\n" % sqrt(covariance[5][5])
self.lastFitString += "R %17.10f\n" % sqrt(covariance[6][6])
self.lastFitString += "\n"
self.lastFitString += "Q Data used when calibrating:\n"
self.lastFitString += str(qData)
return bestGuess,peakList
def _Calculate_spectrum_fired(self):
# delete values from previous measurement
self.delete_all_values()
# load data
rabi_x, rabi_y, unused1, unused2 = self.load_file(self.rabi_file)
xy8_x, xy8_y, xy8_xx, xy8_yy = self.load_file(self.xy8_file)
# performing rabi-fit
rabi_fit_parameters = self.rabi_fit(rabi_x, rabi_y)
rabi_contrast = 200 * rabi_fit_parameters[0] / rabi_fit_parameters[3]
rabi_period = rabi_fit_parameters[1] / 1e3 # /1e3 gives us nanoseconds
rabi_amplitude = rabi_fit_parameters[0]
rabi_level = rabi_fit_parameters[3]
print 'rabi_level: ', rabi_level
# plotting rabi + rabi-fit
rabi_y = np.array(rabi_y) / 1e3
self.y_rabi_lo = min(rabi_y) - 0.02
self.y_rabi_hi = max(rabi_y) + 0.02
rabi_fit_y = Fit.Cosinus_dec(*rabi_fit_parameters)(rabi_x) / 1e3
self._plot_rabi_changed(rabi_x, rabi_y, rabi_fit_y)
# plotting yx8-data
self._plot_xy8_changed(xy8_x, xy8_y, xy8_yy)
# decide if rabi-level or xy8-level (if alternating)
level = rabi_level
if xy8_yy != []:
xy8_level = ((np.array(xy8_y) + np.array(xy8_yy)) / 2).mean()
level = xy8_level
print 'xy8_level: ', xy8_level
# performing xy8 to rabi normalization
xy8norm_x = xy8_x
xy8norm_y = Calculate.do_normalization(xy8_y, rabi_amplitude, level)
xy8norm_yy = []
if xy8_yy != []:
xy8norm_yy = Calculate.do_normalization(xy8_yy, rabi_amplitude,
level)
# plotting xy8norm
self._plot_xy8norm_changed(xy8norm_x, xy8norm_y, xy8norm_yy)
# calculating the spectral density
nu = Calculate.nu_from_tau(
xy8norm_x) #this nu is in MHz, since xy8norm_x is in µs
gamma_e = 1 #setting gamma_e to 1
tau_x = np.array(xy8norm_x) / 1e6 #tau_x is in seconds
if xy8_yy == []:
temp = float(sum(xy8norm_y) / len(xy8norm_y))
if temp < 0.5:
xy8norm_y = 1 - xy8norm_y
spectrum_y = Calculate.S_from_data(tau_x, xy8norm_y, gamma_e,
self.Number_pulses)
spectrum_y = np.array(spectrum_y) / 1e6 #to change to MHz
spectrum_yy = []
if xy8_yy != []:
xy8norm_yy = 1 - xy8norm_yy
spectrum_yy = Calculate.S_from_data(tau_x, xy8norm_yy, gamma_e,
self.Number_pulses)
spectrum_yy = np.array(spectrum_yy) / 1e6 #to change to MHz
# plotting the spectral density
self.spec_min = min(nu)
self.spec_max = max(nu)
self._plot_density_changed(nu, spectrum_y, spectrum_yy)
# saving nu and spectra, to use them in Calculate_depth
self.nu = nu
self.spectrum_y = spectrum_y
self.spectrum_yy = spectrum_yy
def IndustWater(time):
pop = (Gaussian(Fit.PopulationFit(time),pPara)/Gaussian(Fit.PopulationFit(years[-1]),pPara))
pcg = (Gaussian(Fit.PCGDPFit(time),gPara)/Gaussian(Fit.PCGDPFit(years[-1]),gPara))
ele = (Gaussian(Fit.ElectricityFit(time),ePara)/Gaussian(Fit.ElectricityFit(years[-1]),ePara))
spr = (Gaussian(Fit.SteelProductFit(time),sPara)/Gaussian(Fit.SteelProductFit(years[-1]),sPara))
return Data.WaterUseIndustry[years[-1]]*(pop/4+pcg/4+ele/4+spr/4)
