def calc_uncertainty(self):
# 计算一元线性回归的不确定度
num_u_b = self.data['num_b'] * sqrt((1 / (self.data['num_r'] ** 2) - 1) / (8 - 2))
self.data['num_u_b'] = num_u_b
# 计算直径D的不确定度
num_ua_D = Method.a_uncertainty(self.data['list_D'])
num_ub_D = 0.03 / sqrt(3) /1000
num_u_D = sqrt(num_ua_D ** 2 + num_ub_D ** 2)
self.data.update({"num_ua_D":num_ua_D, "num_ub_D":num_ub_D, "num_u_D":num_u_D})
# 电阻率不确定度的合成
num_u_rho_rho = sqrt((num_u_D / self.data['num_D']) ** 2 + (num_u_b / self.data['num_b']) ** 2)
num_rho = self.data['num_rho']
num_u_rho = num_u_rho_rho * num_rho
self.data.update({"num_u_rho_rho": num_u_rho_rho, "num_u_rho": num_u_rho})
# 输出带不确定度的最终结果: 不确定度保留一位有效数字, 物理量结果与不确定度首位有效数字对齐
self.data['final_1'] = Method.final_expression(self.data['num_rho'], self.data['num_u_rho'])
# 单电桥测电阻
# 灵敏度分析
num_S = self.data['num_delta_n'] / self.data['num_delta_R_3']
num_delta_lmd = 0.2 / num_S
num_u_lmd = num_delta_lmd / sqrt(3)
self.data.update({"num_S": num_S, "num_delta_lmd":num_delta_lmd, "num_u_lmd":num_u_lmd})
# 仪器误差
num_delta_yi = InstrumentError.dc_bridge(self.data['num_a_pct'], self.data['num_R_3'],self.data['num_R_0'])
num_u_yi = num_delta_yi / sqrt(3)
num_u_R_x = sqrt(num_u_yi ** 2 + num_u_lmd ** 2)
self.data.update({"num_delta_yi": num_delta_yi, "num_u_yi": num_u_yi, "num_u_R_x": num_u_R_x})
# 输出带不确定度的最终结果: 不确定度保留一位有效数字, 物理量结果与不确定度首位有效数字对齐
self.data['final_2'] = Method.final_expression(self.data['num_R_3'], self.data['num_u_R_x'])
print(self.data['final_2'])
def calc_uncertainty_detail(data_list, result_list):
sunc = Simplified()
uncertain_data = {}
ua_10delta_x = Method.a_uncertainty(result_list['diff_10delta_x'])
ub_10delta_x = sunc.micrometer / sqrt(3)
u_10delta_x = sqrt(ua_10delta_x**2 + ub_10delta_x**2)
u_delta_x = u_10delta_x / 10
ub_S = sqrt((sunc.steel_ruler / 10 / sqrt(3))**2 +
(data_list['delta_s'] / sqrt(3))**2)
ub_b = sqrt((sunc.micrometer / sqrt(3))**2 +
(data_list['delta_b_b'] * result_list['b'] / sqrt(3))**2)
ub_b1 = sqrt((sunc.micrometer / sqrt(3))**2 +
(data_list['delta_b_b'] * result_list['b1'] / sqrt(3))**2)
u_lbd_lbd = sqrt((u_delta_x / result_list['delta_x'])**2 +
(ub_b / result_list['b'] / 2)**2 +
(ub_b1 / result_list['b1'] / 2)**2 + 2 *
((ub_S / (result_list['S'] + result_list['S1']))**2))
u_lbd = u_lbd_lbd * result_list['result_lambda']
final_lbd = Method.final_expression(result_list['result_lambda'],
u_lbd)
uncertain_data['ua_10delta_x'] = ua_10delta_x
uncertain_data['ub_10delta_x'] = ub_10delta_x
uncertain_data['u_10delta_x'] = u_10delta_x
uncertain_data['u_delta_x'] = u_delta_x
uncertain_data['u_S'] = ub_S
uncertain_data['u_b'] = ub_b
uncertain_data['u_b1'] = ub_b1
uncertain_data['u_lbd_lbd'] = u_lbd_lbd
uncertain_data['u_lbd'] = u_lbd
uncertain_data['final'] = final_lbd
return uncertain_data
def calc_uncertainty_d(self):
# 计算光程差d的a,b及总不确定度
Ua_2xita1 = Method.a_uncertainty(
self.data['list_d_2xita1']) # 这里容易写错，一定要用原始数据的数组
Ub_2xita1 = 1.679e-4
U_xita1 = sqrt(Ub_2xita1**2 + Ua_2xita1**2) / 2
Ud1 = abs(self.data['d1'] * U_xita1 /
tan(self.data['d_xita1_average']))
Ub_2xita2 = 1.679e-4
Ud2 = abs(self.data['d2'] * Ub_2xita2 /
(2 * tan(3.14 * self.data['d_2xita2'] / 360)))
self.uncertainty.update({
"Ua_2xita1": Ua_2xita1,
"Ub_2xita1": Ub_2xita1,
"Ua_xita1": Ua_2xita1 / 2,
"Ub_xita1": Ub_2xita1 / 2,
"U_xita1": U_xita1,
"Ud1": Ud1,
"Ub_2xita2": Ub_2xita2,
"Ub_xita2": Ub_2xita2 / 2,
"Ud2": Ud2
})
d1 = self.data['d1']
d2 = self.data['d2']
d_av = (d1 / (Ud1**2) + d2 / (Ud2**2)) / (1 / (Ud1**2) + 1 / (Ud2**2))
Ud_av = sqrt((Ud1**2) * (Ud2**2) / (Ud1**2) + (Ud2**2))
self.uncertainty.update({"d_av": d_av, "Ud_av": Ud_av})
self.data['final1'] = Method.final_expression(d_av, Ud_av)
def calc_uncertainty3(self):
# 计算顶角A的a,b及总不确定度
ua_delta = Method.a_uncertainty(
self.data['list_delta']) # 这里容易写错，一定要用原始数据的数组
ub_delta = (1 / 60) / sqrt(3)
u_delta = sqrt(ua_delta**2 + ub_delta**2)
self.data.update({
"ua_delta": ua_delta,
"ub_delta": ub_delta,
"u_delta": u_delta
})
part_1 = -1 / sin(self.data['aver_A'] / 180 * pi) - sin(
self.data['aver_delta'] / 180 * pi) * cos(
self.data['aver_A'] / 180 * pi) / (sin(
self.data['aver_A'] / 180 * pi)**2)
part_4 = (cos(self.data['aver_A'] / 180 * pi) +
sin(self.data['aver_delta'] / 180 * pi)) / sin(
self.data['aver_A'] / 180 * pi)
n_delta = cos(
self.data['aver_delta'] / 180 * pi) * part_4 / self.data['n2']
n_A = part_1 * part_4 / self.data['n2']
u_n2 = sqrt((n_delta * u_delta / 180 * pi)**2 +
(n_A * self.data['u_A'] / 180 * pi)**2)
self.data['u_n2'] = u_n2
self.data['final_n2'] = Method.final_expression(self.data['n2'], u_n2)
def calc_uncertainty1(self):
# 计算顶角A的a,b及总不确定度
ua_A = Method.a_uncertainty(self.data['list_A']) # 这里容易写错，一定要用原始数据的数组
ub_A = (1 / 60) / sqrt(3) / 2
u_A = sqrt(ua_A**2 + ub_A**2)
self.data.update({"ua_A": ua_A, "ub_A": ub_A, "u_A": u_A})
self.data['final_A'] = Method.final_expression(self.data['aver_A'],
u_A)
def calc_uncertainty(self):
num_sum = 0
for i in range(0, 8):
num_sum += (self.data['list_Y'][i] -
self.data['list_X'][i] * self.data['num_a'])**2
num_u_A = sqrt(num_sum / (48 * 21))
num_u_E = num_u_A * self.data['num_para']
num_eta = abs(self.data['num_E'] - 70 * 1e9) / (70 * 1e9) * 100
self.data['num_u_A'] = num_u_A
self.data['num_u_E'] = num_u_E
self.data['num_eta'] = num_eta
self.data['final'] = Method.final_expression(
self.data['num_E'] / 1e9, self.data['num_u_E'] / 1e9)
def calc_uncertainty(self):
b = self.data['b']
n = len(self.data['arr_D'])
r = self.data['r']
lbd = self.data['lambda'] * 1e-6
ua_b = b * sqrt((1 / (n - 2)) * ((1 / (r ** 2)) - 1))
ub_b = 0.005 / sqrt(3)
u_b = sqrt(ua_b ** 2 + ub_b ** 2)
u_R = u_b / (4 * lbd)
R = self.data['R']
res, unc, pwr = Method.final_expression(R, u_R)
self.uncertainty['ua_b'] = ua_b
self.uncertainty['ub_b'] = ub_b
self.uncertainty['u_b'] = u_b
self.uncertainty['u_R'] = u_R
self.data['final'] = "(%.0f ± %.0f)e%d" % (res, unc, int(pwr))
pass
def calc_uncertainty(self):
# 计算光程差d的a,b及总不确定度
ua_d = Method.a_uncertainty(self.data['list_d']) # 这里容易写错，一定要用原始数据的数组
ub_d = 0.00005 / sqrt(3)
u_d = sqrt(ua_d**2 + ub_d**2)
self.uncertainty.update({"ua_d": ua_d, "ub_d": ub_d, "u_d": u_d})
# 计算圈数N的不确定度
N = self.data['N']
u_N = 1 / sqrt(3)
self.uncertainty['u_N'] = u_N
d, N = self.data['d'], self.data['N']
# 波长的不确定度合成
u_lbd_lbd = sqrt((u_d / d)**2 + (u_N / N)**2)
lbd = self.data['lbd']
u_lbd = u_lbd_lbd * lbd
self.uncertainty.update({"u_lbd_lbd": u_lbd_lbd, "u_lbd": u_lbd})
# 输出带不确定度的最终结果: 不确定度保留一位有效数字, 物理量结果与不确定度首位有效数字对齐
self.data['final'] = Method.final_expression(lbd, u_lbd)
def calc_uncertainty2(self):
# 计算顶角A的a,b及总不确定度
ua_delta_m = Method.a_uncertainty(
self.data['list_delta_m']) # 这里容易写错，一定要用原始数据的数组
ub_delta_m = (1 / 60) / sqrt(3)
u_delta_m = sqrt(ua_delta_m**2 + ub_delta_m**2)
self.data.update({
"ua_delta_m": ua_delta_m,
"ub_delta_m": ub_delta_m,
"u_delta_m": u_delta_m
})
part_1 = cos((self.data['aver_delta_m'] / 180 * pi +
self.data['aver_A'] / 180 * pi) / 2)
part_4 = sin(self.data['aver_A'] / 180 * pi / 2)
n_delta_m = 0.5 * part_1 / part_4
n_A = -sin(self.data['aver_delta_m'] / 180 * pi / 2) / 2 / (part_4**2)
u_n1 = sqrt((n_delta_m * u_delta_m / 180 * pi)**2 +
(n_A * self.data['u_A'] / 180 * pi)**2)
self.data['u_n1'] = u_n1
self.data['final_n1'] = Method.final_expression(self.data['n1'], u_n1)
def calc_uncertainty_Rh(self):
Ua_2xita1_r = Method.a_uncertainty(
self.data['list_r_2xita1']) # 这里容易写错，一定要用原始数据的数组
Ub_2xita1_r = 1.679e-4
Ua_xita1_r = Ua_2xita1_r / 2
Ub_xita1_r = Ub_2xita1_r / 2
U_xita1_r = sqrt(Ub_xita1_r**2 + Ua_xita1_r**2)
self.uncertainty.update({
"Ua_xita1_r": Ua_xita1_r,
"Ub_xita1_r": Ub_xita1_r,
"U_xita1_r": U_xita1_r,
"Ua_2xita1_r": Ua_2xita1_r,
"Ub_2xita1_r": Ub_2xita1_r
})
U_r_RH = self.data['r_RH'] * sqrt(
(self.uncertainty['Ud_av'] / self.uncertainty['d_av'])**2 +
(U_xita1_r / tan(self.data['r_xita1_average'])**2))
self.uncertainty.update({"U_r_RH": U_r_RH})
self.data['final2_r'] = Method.final_expression(
self.data['r_RH'] * 1e6, U_r_RH * 1e4)
Ua_2xita1_b = Method.a_uncertainty(
self.data['list_b_2xita1']) # 这里容易写错，一定要用原始数据的数组
Ub_2xita1_b = 1.679e-4
Ua_xita1_b = Ua_2xita1_b / 2
Ub_xita1_b = Ub_2xita1_b / 2
U_xita1_b = sqrt(Ub_xita1_b**2 + Ua_xita1_b**2)
self.uncertainty.update({
"Ua_xita1_b": Ua_xita1_b,
"Ub_xita1_b": Ub_xita1_b,
"U_xita1_b": U_xita1_b,
"Ua_2xita1_b": Ua_2xita1_b,
"Ub_2xita1_b": Ub_2xita1_b
})
U_b_RH = self.data['b_RH'] * sqrt(
(self.uncertainty['Ud_av'] / self.uncertainty['d_av'])**2 +
(U_xita1_b / tan(self.data['b_xita1_average'])**2))
self.uncertainty.update({"U_b_RH": U_b_RH})
self.data['final2_b'] = Method.final_expression(
self.data['b_RH'] * 1e6, U_b_RH * 1e4)
Ua_2xita1_p = Method.a_uncertainty(
self.data['list_p_2xita1']) # 这里容易写错，一定要用原始数据的数组
Ub_2xita1_p = 1.679e-4
Ua_xita1_p = Ua_2xita1_p / 2
Ub_xita1_p = Ub_2xita1_p / 2
U_xita1_p = sqrt(Ub_xita1_p**2 + Ua_xita1_p**2)
self.uncertainty.update({
"Ua_xita1_p": Ua_xita1_p,
"Ub_xita1_p": Ub_xita1_p,
"U_xita1_p": U_xita1_p,
"Ua_2xita1_p": Ua_2xita1_p,
"Ub_2xita1_p": Ub_2xita1_p
})
U_p_RH = self.data['p_RH'] * sqrt(
(self.uncertainty['Ud_av'] / self.uncertainty['d_av'])**2 +
(U_xita1_p / tan(self.data['p_xita1_average'])**2))
self.uncertainty.update({"U_p_RH": U_p_RH})
self.data['final2_p'] = Method.final_expression(
self.data['p_RH'] * 1e6, U_p_RH * 1e4)
RH = (self.simple_Rh(self.data['r_RH'], U_r_RH) +
self.simple_Rh(self.data['b_RH'], U_b_RH) +
self.simple_Rh(self.data['p_RH'], U_p_RH)) / ((1 / U_r_RH**2) +
(1 / U_b_RH**2) +
(1 / U_p_RH**2))
self.data['RH'] = RH
U_RH = sqrt(1 / ((1 / U_r_RH**2) + (1 / U_b_RH**2) + (1 / U_p_RH**2)))
self.data['U_RH'] = U_RH
self.data['final2'] = Method.final_expression(RH * 1e6, U_RH * 1e4)