def main():
io = Io()
io.eval_args()
ret = {'ok': True}
cmc = True
base_doc = io.get_base_doc("ce3")
for id in io.ids:
id = id.replace("\"", "")
doc = io.get_doc_db(id)
if io.update:
doc = io.update_cal_doc(doc, base_doc)
ana = Analysis(doc)
io.save_doc(ana.build_doc())
print(json.dumps(ret))
def main():
io = Io()
io.eval_args()
# holt Messdaten aus --db
meas_doc = io.load_doc()
# holt Konstanten ect. aus --db
base_doc = io.get_base_doc("se2")
# merge der beiden Dokumente
doc = io.update_cal_doc(meas_doc, base_doc)
res = Analysis(doc)
# Berechnungen-Klasse leitet vom Standard se2 ab
cal = Cal(doc)
print(cal.Date.parse_labview_date("Date"))
print(cal.ToDo.Pres.get_value("target", "mbar"))
# Unsicherheits-Klasse leitet auch vom Standard se2 ab
unc = Uncert(doc)
## Bsp. Berechn. Kalibrierdruck, Unsicherh.
cal.pressure_cal(res)
unc.temperature_vessel(res)
def main():
io = Io()
io.eval_args()
doc = io.get_state_doc(name="se3")
base_doc = io.get_base_doc(name="se3")
for k, v in base_doc.items():
doc['State'][k] = v
cal = Cal(doc)
res = Analysis(doc)
cal.time_state(res)
cal.volume_state(res)
cal.pressure_state(res)
cal.outgas_state(res)
cal.pressure_loss(res)
cal.temperature_state(res)
chk = Analysis(res.build_doc())
cal.check_state(res, chk)
io.save_doc(chk.build_doc("Check"))
def main():
io = Io()
io.eval_args()
ret = {'ok': True}
cmc = False
base_doc = io.get_base_doc("se3")
for id in io.ids:
doc = io.get_doc_db(id)
if io.update:
doc = io.update_cal_doc(doc, base_doc)
cal = Cal(doc)
ana = Analysis(doc, analysis_type="direct")
cus_dev = init_customer_device(doc)
cus_dev.range_trans(ana)
cal.temperature_comp(ana)
cal.temperature_gas_direct(ana)
cal.pressure_gn_corr(ana)
cal.pressure_gn_mean(ana)
temperature_dict = ana.pick_dict('Temperature', 'compare')
gas = cal.Aux.get_gas()
ind_dict = cal.Pres.get_dict('Type', 'ind')
offset_dict = cal.Pres.get_dict('Type', 'ind_offset')
range_dict = cal.Range.get_dict('Type', 'ind')
ind = cus_dev.pressure(ind_dict,
temperature_dict,
range_dict=range_dict,
unit=ana.pressure_unit,
gas=gas)
offset = cus_dev.pressure(offset_dict,
temperature_dict,
range_dict=range_dict,
unit=ana.pressure_unit,
gas=gas)
ana.store("Pressure", "ind", ind, ana.pressure_unit)
ana.store("Pressure", "offset", offset, ana.pressure_unit)
ana.store("Pressure", "ind_corr", ind - offset, ana.pressure_unit)
# error for rating procedures
p_ind = ana.pick("Pressure", "ind_corr", cal.unit)
p_cal = ana.pick("Pressure", "cal", cal.unit)
ana.store('Error', 'ind', p_ind / p_cal - 1.0, '1')
## uncert. calculation
uncert = Uncert(doc)
## we have cmc entries for the FRS
## so we can use the GN uncertainty
u = uncert.contrib_pressure_fill(p_cal, cal.unit)
ana.store("Uncertainty", "standard", u / p_cal, "1")
io.save_doc(ana.build_doc())
print(json.dumps(ret))
def main():
io = Io()
io.eval_args()
args = sys.argv
fail = False
ret = {'ok': True}
if '--ids' in args:
idx_ids = args.index('--ids') + 1
try:
ids = args[idx_ids].split(';')
except:
fail = True
if '-u' in args:
update = True
else:
update = False
if not fail and len(ids) > 0:
base_doc = io.get_base_doc("dkm_ppc4")
for id in ids:
doc = io.get_doc_db(id)
if update:
doc = io.update_cal_doc(doc, base_doc)
cus_dev = init_customer_device(doc)
res = Analysis(doc)
uncert = Uncert(doc)
cal = Cal(doc)
cal.temperature(res)
cal.temperature_correction(res)
cal.pressure_res(res)
cal.mass_total(res)
cal.pressure_cal(res)
# cal uncert of standard
uncert.total(res)
## calculate customer indication
gas = cal.Aux.get_gas()
## todo meas temp room, gas
temperature_dict = {}
offset_dict = cal.Pres.get_dict('Type', 'ind_offset')
ind_dict = cal.Pres.get_dict('Type', 'ind')
offset = cus_dev.pressure(offset_dict,
temperature_dict,
unit=cal.unit,
gas=gas)
ind = cus_dev.pressure(ind_dict,
temperature_dict,
unit=cal.unit,
gas=gas)
ind_corr = ind - offset
res.store("Pressure", "offset", offset, cal.unit)
res.store("Pressure", "ind", ind, cal.unit)
res.store("Pressure", "ind_corr", ind_corr, cal.unit)
# error for rating procedures
p_ind_corr = res.pick("Pressure", "ind_corr", cal.unit)
p_cal = res.pick("Pressure", "cal", cal.unit)
res.store('Error', 'ind', p_ind_corr / p_cal - 1, '1')
cus_dev.range_trans(res)
print(p_ind_corr / p_cal - 1)
io.save_doc(res.build_doc())
def main():
io = Io()
io.eval_args()
args = sys.argv
fail = False
ret = {'ok': True}
if '--ids' in args:
idx_ids = args.index('--ids') + 1
try:
ids = args[idx_ids].split(';')
except:
fail = True
if '-u' in args:
update = True
else:
update = False
if not fail and len(ids) > 0:
base_doc = io.get_base_doc("frs5")
for id in ids:
doc = io.get_doc_db(id)
if update:
doc = io.update_cal_doc(doc, base_doc)
cal = Cal(doc)
res = Analysis(doc)
uncert = Uncert(doc)
cal.temperature(res)
cal.pressure_res(res)
cal.pressure_cal(res)
uncert.total_standard(res)
gas = cal.Aux.get_gas()
devs = (
"1T_1",
"1T_2",
"1T_3",
"5T_1",
"10T_1",
"10T_2",
"10T_3",
"50T_1",
"100T_1",
"100T_2",
"100T_3",
)
p_cal = res.pick("Pressure", "cal", cal.unit)
for dev in devs:
p_offset = cal.Pres.get_value('{}-offset'.format(dev),
cal.unit)
p_ind = cal.Pres.get_value('{}-ind'.format(dev), cal.unit)
p_ind_corr = p_ind - p_offset
res.store("Pressure", '{}-offset'.format(dev), p_offset,
cal.unit)
res.store("Pressure", '{}-ind'.format(dev), p_ind, cal.unit)
res.store("Pressure", '{}-ind_corr'.format(dev), p_ind_corr,
cal.unit)
res.store('Error', '{}-ind'.format(dev),
p_ind_corr / p_cal - 1, '1')
print(dev)
print("----------------------------")
print(p_ind_corr / p_cal - 1)
print("----------------------------")
print("----------------------------")
print(p_cal)
io.save_doc(res.build_doc())
def main():
io = Io()
io.eval_args()
args = sys.argv
fail = False
ret = {'ok':True}
if '--ids' in args:
idx_ids = args.index('--ids') + 1
try:
ids = args[idx_ids].split('@')
except:
fail = True
if '--min_pressure' in args:
min_i = args.index('--min_pressure') + 1
try:
min_pressure = float(args[min_i])
except:
fail = True
if '--max_pressure' in args:
max_i = args.index('--max_pressure') + 1
try:
max_pressure = float(args[max_i])
except:
fail = True
if '--pressure_unit' in args:
unit_i = args.index('--pressure_unit') + 1
try:
pressure_unit = str(args[unit_i])
except:
fail = True
if not fail and len(ids) > 0:
base_doc = io.get_base_doc("se3")
for id in ids:
doc = io.get_doc_db(id)
todo = ToDo(doc)
const = Constants(base_doc)
conv = const.get_conv(from_unit=pressure_unit, to_unit=todo.pressure_unit)
max_pressure = max_pressure * conv
min_pressure = min_pressure * conv
todo_dict, rest_dict = todo.shape_pressure(min_p=min_pressure, max_p=max_pressure, unit = todo.pressure_unit)
doc["Calibration"]["ToDo"]["Values"]["Pressure"] = todo_dict
io.save_doc(doc)
if rest_dict:
## generate a new doc with issue+1 and rest todo
rest_doc = copy.deepcopy(doc)
id_arr = rest_doc["_id"].split("_")
issue = str(int(id_arr[-1]) + 1 + 10000)[1:5]
id_arr[1] = issue
rest_doc["_id"] = "_".join(id_arr)
rest_doc["Calibration"]["Issue"] = issue
rest_doc["Calibration"]["ToDo"]["Values"]["Pressure"] = rest_dict
del rest_doc["_rev"]
io.save_doc(rest_doc)
else:
ret = {"error": "no --ids found"}
print(json.dumps(ret))
plt.plot(p_cal_l, u_l, 'o', color="blue", label="$f_l$")
plt.xscale('symlog', linthreshx=1e-12)
plt.xlabel('$p_{}$ in {}'.format("{cal}", target_unit))
#plt.ylabel('$\sqrt{u(p_{fill})^2 + u(f_i)^2}$ (relative, k=1)')
plt.ylabel('$u(p_{fill}) (reative, k=1)')
plt.ticklabel_format(style='sci', scilimits=(-3, 4), axis='y')
for i, v in enumerate(p_cal):
plt.text(p_cal[i],
u[i],
"${}$".format(round(p_fill[i], 1)),
horizontalalignment='left',
verticalalignment='bottom',
rotation=90.)
plt.grid(True)
plt.legend()
plt.savefig(
"filling_pressure_overview.pdf",
orientation='landscape',
papertype='a4',
)
plt.show()
if __name__ == "__main__":
io = Io()
base_doc = io.get_base_doc(name="se3")
cal = Cal(base_doc)
main(cal)
def main():
io = Io()
io.eval_args()
args = sys.argv
fail = False
ret = {'ok': True}
unit = "Pa"
if '--ids' in args:
idx_ids = args.index('--ids') + 1
try:
ids = args[idx_ids]
ids = ids.split('@')
except:
fail = True
if not fail and len(ids) > 0:
for id in ids:
id = id.replace("\"", "")
## -------------------------
## se3
## -------------------------
base_doc_se3 = io.get_base_doc("se3")
doc = io.get_doc_db(id)
doc = io.update_cal_doc(doc, base_doc_se3)
res = Analysis(doc, analysis_type="expansion")
uncert_se3 = UncertSe3(doc)
cal_se3 = CalSe3(doc)
f_names = cal_se3.get_expansion_name()
f_name = f_names[0]
cal_se3.pressure_gn_corr(res)
cal_se3.pressure_gn_mean(res)
cal_se3.temperature_before(res)
cal_se3.temperature_after(res)
cal_se3.real_gas_correction(res)
cal_se3.correction_delta_height(res)
rg = res.pick("Correction", "rg", "1")
dh = res.pick("Correction", "delta_heigth", "1")
p_0 = res.pick("Pressure", "fill", unit)
T_0 = res.pick("Temperature", "before", "K")
T_1 = res.pick("Temperature", "after", "K")
u_p_0 = uncert_se3.contrib_pressure_fill(p_0, unit, skip_type="A")
u_T_1 = uncert_se3.contrib_temperature_vessel(T_1,
"K",
skip_type="A")
u_T_0 = uncert_se3.contrib_temperature_volume_start(T_0,
"K",
f_names,
skip_type="A")
## -------------------------
## p_nd
## -------------------------
customer_device = doc['Calibration']['CustomerObject']
CustomerDevice = Cdg(doc, customer_device)
temperature_dict = res.pick_dict('Temperature', 'before')
gas = cal_se3.get_gas()
ind_dict = cal_se3.Pres.get_dict('Type', 'nd_ind')
offset_dict = cal_se3.Pres.get_dict('Type', 'nd_offset')
ind = CustomerDevice.pressure(ind_dict,
temperature_dict,
unit=unit,
gas=gas)
offset = CustomerDevice.pressure(offset_dict,
temperature_dict,
unit=unit,
gas=gas)
p_nd = ind - offset
u_p_nd = CustomerDevice.get_total_uncert(p_nd,
unit,
unit,
skip_type="A")
## -------------------------
## frs5
## -------------------------
base_doc_frs5 = io.get_base_doc("frs5")
doc = io.update_cal_doc(doc, base_doc_frs5)
res = Analysis(doc, analysis_type="expansion")
cal_frs = CalFrs(doc)
res = Analysis(doc)
uncert = UncertFrs(doc)
cal_frs.temperature(res)
cal_frs.pressure_res(res)
cal_frs.pressure_cal(res)
uncert.total_standard(res, no_type_a=True)
p_1 = res.pick("Pressure", "cal", unit)
u_p_1 = res.pick("Uncertainty", "standard", "1") * p_1
## -------------------------
## f
## -------------------------
corr_tem = T_0 / T_1
f = (p_1 - p_nd) / (p_0 * rg * dh) * corr_tem
s_p_1 = 1 / p_0 * corr_tem
s_p_0 = -(p_1 - p_nd) / (p_0**2) * corr_tem
s_p_nd = 1 / p_0 * corr_tem
s_T_0 = (p_1 - p_nd) / (p_0) / T_1
s_T_1 = -(p_1 - p_nd) / (p_0) * T_0 / T_1**2
uc_p_1 = (s_p_1 * u_p_1)
uc_p_0 = (s_p_0 * u_p_0)
uc_p_nd = (s_p_nd * u_p_nd)
uc_T_1 = (s_T_1 * u_T_1)
uc_T_0 = (s_T_0 * u_T_0)
u = (uc_p_1**2 + uc_p_0**2 + uc_p_nd**2 + uc_T_1**2 +
uc_T_0**2)**0.5
res.store("Expansion", f_name, f, "1")
res.store("Pressure", "nd_offset", offset, unit)
res.store("Pressure", "nd_corr", p_nd, unit)
res.store("Uncertainty", "nd_corr", u_p_nd, unit)
res.store("Pressure", "fill", p_0, unit)
res.store("Uncertainty", "fill", u_p_0, unit)
res.store("Pressure", "cal", p_1, unit)
res.store("Uncertainty", "cal", u_p_1 * p_1, unit)
res.store("Temperature", "before", T_0, "K")
res.store("Temperature", "after", T_1, "K")
res.store("Uncertainty", "before", u_T_0, "K")
res.store("Uncertainty", "after", u_T_1, "K")
res.store("Uncertainty", "total", u, "1")
res.store("Correction", "delta_heigth", dh, "1")
res.store("Correction", "rg", rg, "1")
res.store("Correction", "temperature", corr_tem, "1")
doc = res.build_doc()
doc["Calibration"]["Standard"] = [
base_doc_se3["Standard"], base_doc_frs5["Standard"]
]
io.save_doc(doc)
print("------------------- p_nd:")
print(p_nd)
print(ind_dict["SdValue"])
print(offset_dict["SdValue"])
print("-------------------u p_0:")
print(u_p_0 / p_0)
print("-------------------u p_1:")
print(u_p_1)
print("-------------------u p_nd:")
print(u_p_nd)
#f = np.delete(f, f.argmin())
#f = np.delete(f, f.argmax())
print("-------------------f:")
print(f)
print(np.mean(f))
print(np.std(f))
print(np.std(f) / np.mean(f))
print(np.std(f) / np.mean(f) / (len(f) - 1)**0.5)
print("-------------------u:")
print(u / f)
def main():
io = Io()
doc = io.get_base_doc("se3")
with open("vpy/standard/se3/base_doc.json", 'w') as f:
json.dump(doc, f, indent=4, ensure_ascii=False)
def main():
io = Io()
io.eval_args()
args = sys.argv
fail = False
ret = {'ok': True}
# with open(".\script\se2\input.json") as input_json:
# print(json.load(input_json))
if '--ids' in args:
idx_ids = args.index('--ids') + 1
try:
ids = args[idx_ids]
ids = ids.split('@')
except:
fail = True
if '-u' in args: # erzeugt Einträge für KOnstatne und Calibrierobjekte
update = True
else:
update = False
if not fail and len(ids) > 0:
base_doc = io.get_base_doc("se2")
for id in ids:
id = id.replace("\"", "")
doc = io.get_doc_db(id)
if update:
doc = io.update_cal_doc(doc, base_doc)
ana = Analysis(doc, analysis_type="expansion")
cal = Cal(doc)
if 'CustomerObject' in doc['Calibration']:
customer_device = doc['Calibration']['CustomerObject']
dev_class = customer_device.get('Class', "generic")
if dev_class == 'SRG':
CustomerDevice = Srg(doc, customer_device)
if dev_class == 'CDG':
CustomerDevice = Cdg(doc, customer_device)
if dev_class == 'RSG':
CustomerDevice = Rsg(doc, {})
cal.temperature_after(ana)
cal.temperature_room(ana)
cal.pressure_cal(ana)
cal.pressure_ind(ana)
cal.pressure_offset(ana)
cal.pressure_indication_error(ana)
#cal.measurement_time(ana)
cal.faktor(ana)
cal.range(ana)
io.save_doc(ana.build_doc())
else:
ret = {"error": "no --ids found"}
# print writes back to relay server by writing to std.out
print(json.dumps(ret))
def main():
io = Io()
io.eval_args()
if io.ids:
doc = io.get_doc_db(io.ids[0])
cal = Cal(doc)
t_arr = cal.Temp.get_array("ch_", channels, "_after", "C")
cor_arr = cal.TDev.get_array("corr_ch_", channels, "", "K")
if io.args.point:
p = int(io.args.point[0])
else:
p = -1
if io.n:
doc = io.get_base_doc("se3")
res = requests.post(conf_dev_hub.get("url"),
json=conf_dev_hub.get("dmm_task"))
res = res.json()
doc["Measurement"] = {"Values": {"Temperature": res.get("Result")}}
cal = Cal(doc)
t_arr = cal.Temp.get_array("ch_", channels, "_now", "C")
cor_arr = cal.TDev.get_array("corr_ch_", channels, "", "K")
p = 0
t = t_arr + cor_arr
t_i = np.array([e[p] for e in t])
fig = plt.figure()
ax = fig.gca(projection='3d')
x_arr = []
y_arr = []
z_arr = []
sl_arr = [] ## sensor labels
cl_arr = [] ## chamber labels
s = 0
for i, _ in enumerate(y_vec):
alpha = gen_alpha(n_vec[i], o_vec[i], dir_vec[i])
x = gen_x(alpha, r_vec[i])
y = np.full(n_vec[i], y_vec[i])
z = gen_z(alpha, r_vec[i])
for j in range(0, n_vec[i]):
if put_sensor(dist_vec[i], j):
x_arr.append(x[j])
y_arr.append(y[j])
z_arr.append(z[j])
cl = "$C_{}{}{} D_{}{}{}$".format("{", i, "}", "{", j, "}")
cl_arr.append(cl)
sl = "$ch_{}{}{}$".format("{", channels[s], "}")
sl_arr.append(sl)
ax.text(x[j], y[j], z[j], sl)
## next sensor:
s = s + 1
## helper
if i != 0 and i != 9:
alpha = gen_alpha(n_h, 0)
x = gen_x(alpha, rh_vec[i])
y = np.full(n_h, y_vec[i])
z = gen_z(alpha, rh_vec[i])
ax.plot(x, y, z, c="lightgray")
fig.colorbar(ax.scatter(x_arr,
y_arr,
z_arr,
c=t_i,
cmap=conf_plot.get("color_map"),
s=conf_plot.get("sphere_size"),
alpha=0.5),
ax=ax)
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('w')
ax.yaxis.pane.set_edgecolor('w')
ax.zaxis.pane.set_edgecolor('w')
ax.grid(False)
ax.set_title(conf_plot.get("title").format(date=date))
ax.set_xlabel(conf_plot.get("xlab"))
ax.set_zlabel(conf_plot.get("zlab"))
ax.set_ylabel(conf_plot.get("ylab"))
f = conf_plot.get("axis_enlarge")
ax.set_xlim3d(-f * r_o, f * r_o)
ax.set_ylim3d(-y_t, y_t)
ax.set_zlim3d(-f * r_o, f * r_o)
plt.show()
def main():
io = Io()
# holt Messdaten aus --db
io.eval_args()
meas_doc = io.load_doc()
# holt Konstanten ect. aus --db
base_doc = io.get_base_doc("se2")
# merge der beiden Dokumente
doc = io.update_cal_doc(meas_doc, base_doc)
ana = Analysis(doc)
res = Result(doc)
val = Values(doc)
# Berechnungen-Klasse leitet vom Standard se2 ab
cal = Cal(doc)
# Unsicherheits-Klasse leitet auch vom Standard se2 ab
unc = Uncert(doc)
cal.temperature_after(ana)
cal.temperature_room(ana)
cal.pressure_cal(ana)
cal.pressure_ind(ana)
cal.pressure_offset(ana)
cal.pressure_indication_error(ana)
cal.measurement_time(ana)
cal.reject_outliers_index(ana)
cal.make_main_maesurement_index(ana)
cal.make_pressure_range_index(ana)
cal.fit_thermal_transpiration(ana)
cal.make_AuxValues_section(ana)
unc.make_offset_stability(ana)
unc.repeat_rel(ana)
unc.u_PTB_rel(ana)
unc.total(ana)
res.make_error_table(ana)
res.make_formula_section(ana)
# key = self.Pres.round_to_n(p_cal, 2)
# p_cal = [np.mean(g.values.tolist()) for _, g in pd.DataFrame(p_cal).groupby(key)]
#print(pd.Series(ana.pick("Pressure","cal","mbar")))
#print(pd.DataFrame(ana.pick("Pressure","cal","mbar")).head())
doc = ana.build_doc("Analysis", doc)
doc = res.build_doc("Result", doc)
io.save_doc(doc)
disp = Display(doc)
disp.SE2_CDG_offset_abs().savefig("offset_stability_abs_" +
str(doc["Calibration"]["Certificate"]) +
".pdf")
disp.SE2_CDG_offset_rel().savefig("offset_stability_rel_" +
str(doc["Calibration"]["Certificate"]) +
".pdf")
disp.SE2_CDG_error_plot().savefig("fit_thermal_transpiration_" +
str(doc["Calibration"]["Certificate"]) +
".pdf")
print("*******")
p_cal = ana.pick("Pressure", "cal", "mbar")
print("*******")
res.ToDo.make_average_index(p_cal, "mbar")
print(res.ToDo.average_index)
print(5 < 3 < 5)
a = np.pi**50
print(val.round_to_uncertainty(a, 0.097, 2))
print(val.round_to_uncertainty_array([123, 456, 789], [0.01, 1, 10], 2))
print(val.round_to_uncertainty(0., 0.01, 2))
print(doc["Calibration"]["CustomerObject"]["Class"])
print(doc["Calibration"]["CustomerObject"]["Owner"]["Name"])
print(doc["Calibration"]["ToDo"]["Name"])
print(doc["Calibration"]["ToDo"]["Values"]["Pressure"]["Unit"])
print(doc["Calibration"]["ToDo"]["Type"])
print(val.unit_convert(5, "Torr", "mbar"))
print(val.unit_convert(5, "Torr"))
print(val.unit_convert(np.asarray([1, 2, 3, 4]), "Torr"))
print(val.unit_convert(np.asarray([1, 2, 3, 4]), "C"))
print(val.unit_convert(np.asarray([1, 2, 3, 4]), "C", "K"))
print(val.unit_convert(np.asarray([1, 2, 3, 4]), "K", "C"))
print(cal.Cons.get_conv("mbar", "Torr"))
print(val.get_object("Type", "p_fill"))
print(cal.Cons.get_conv("C", "K"))
def main():
io = Io()
io.eval_args()
ret = {'ok':True}
cmc = True
base_doc = io.get_base_doc("se3")
for id in io.ids:
id = id.replace("\"", "")
doc = io.get_doc_db(id)
if io.update:
doc = io.update_cal_doc(doc, base_doc)
cal = Cal(doc)
if io.auxval: ## get new the AuxValues from related (meas_date) state measurement
meas_date = cal.Date.first_measurement()
state_doc = io.get_state_doc("se3", date=meas_date)
ana = Analysis(doc, analysis_type="expansion")
cal.insert_state_results(ana, state_doc)
else: ## keep AuxValues from Calibration.Analysis.AuxValues
auxvalues = doc.get('Calibration').get('Analysis', {}).get('AuxValues', {})
ana = Analysis(doc, insert_dict={'AuxValues': auxvalues}, analysis_type="expansion")
cus_dev = init_customer_device(doc)
uncert = Uncert(doc)
cal.pressure_gn_corr(ana)
cal.pressure_gn_mean(ana)
cal.deviation_target_fill(ana)
cal.temperature_before(ana)
cal.temperature_after(ana)
cal.temperature_room(ana)
cal.temperature_gas_expansion(ana)
cal.real_gas_correction(ana)
cal.volume_add(ana)
cal.volume_start(ana)
cal.expansion(ana)
cal.pressure_rise(ana)
cal.correction_delta_height(ana)
cal.correction_f_pressure(ana)
cal.pressure_cal(ana)
cal.error_pressure_rise(ana)
cal.deviation_target_cal(ana)
## uncert. calculation
if cmc:
# bis update CMC Einträge --> vorh. CMC Einträge
# cal uncertainty of standard
uncert.cmc(ana)
else:
uncert.define_model()
uncert.gen_val_dict(ana)
uncert.gen_val_array(ana)
uncert.volume_start(ana)
uncert.volume_5(ana)
uncert.pressure_fill(ana)
uncert.temperature_after(ana)
uncert.temperature_before(ana)
uncert.expansion(ana)
uncert.total(ana)
## calculate customer indication
gas = cal.Aux.get_gas()
temperature_dict = ana.pick_dict('Temperature', 'after')
offset_dict = cal.Pres.get_dict('Type', 'ind_offset' )
ind_dict = cal.Pres.get_dict('Type', 'ind' )
range_dict = cal.Range.get_dict('Type', 'ind' )
offset = cus_dev.pressure(offset_dict, temperature_dict, range_dict=range_dict, unit = cal.unit, gas=gas)
ind = cus_dev.pressure(ind_dict, temperature_dict, range_dict=range_dict, unit = cal.unit, gas=gas)
ana.store("Pressure", "offset", offset, cal.unit)
ana.store("Pressure", "ind", ind, cal.unit)
ana.store("Pressure", "ind_corr", ind - offset, cal.unit)
p_ind = ana.pick("Pressure", "ind_corr", cal.unit)
p_cal = ana.pick("Pressure", "cal" , cal.unit)
if cal.ToDo.type == "error":
ana.store('Error', 'ind', p_ind/p_cal-1, '1')
cus_dev.range_trans(ana)
if cal.ToDo.type == "sigma":
ana.store('Error', 'ind', p_ind/p_cal-1, '1') ## used for check analysis
ana.store('Sigma', 'eff', p_ind/p_cal, '1')
io.save_doc(ana.build_doc())
print(json.dumps(ret))
def main():
io = Io()
io.eval_args()
doc = io.load_doc()
unit = "Pa"
if doc:
## save the doc in ana.org
res = Analysis(doc, analysis_type='expansion')
const = Constants(doc=doc)
val = Values({})
## -------------------------
## SE3
## -------------------------
base_doc_se3 = io.get_base_doc("se3")
se3_doc = io.update_cal_doc(doc, base_doc_se3)
se3_calc = Se3Calc(se3_doc)
uncert_se3 = Se3Uncert(se3_doc)
f_names = se3_calc.get_expansion_name()
f_name = f_names[0]
se3_calc.temperature_before(res)
se3_calc.temperature_after(res)
se3_calc.temperature_room(res)
se3_calc.pressure_gn_corr(res)
se3_calc.pressure_gn_mean(res)
se3_calc.expansion(res)
se3_calc.time_meas(res)
se3_calc.real_gas_correction(res)
rg = res.pick("Correction", "rg", "1")
p_0 = res.pick("Pressure", "fill", "Pa")
p_1 = res.pick("Pressure", "cal", "Pa")
T_0 = res.pick("Temperature", "before", "K")
T_1 = res.pick("Temperature", "after", "K")
u_p_0 = uncert_se3.contrib_pressure_fill(p_0, unit, skip_type="A")
u_T_1 = uncert_se3.contrib_temperature_vessel(T_1, "K", skip_type="A")
u_T_0 = uncert_se3.contrib_temperature_volume_start(T_0,
"K",
f_names,
skip_type="A")
res.store("Pressure", "fill", p_0, unit)
res.store("Uncertainty", "fill", u_p_0, unit)
res.store("Temperature", "before", T_0, "K")
res.store("Temperature", "after", T_1, "K")
res.store("Uncertainty", "before", u_T_0, "K")
res.store("Uncertainty", "after", u_T_1, "K")
res.store("Correction", "rg", rg, "1")
## old Standard section does not have delta_heigth
## values
## dh correction for f_s = 0.9999609272217588
dh = 0.9999609272217588
res.store("Correction", "delta_heigth", np.full(len(p_0), dh), "1")
## -------------------------
## frs5
## -------------------------
base_doc_frs5 = io.get_base_doc("frs5")
frs_doc = io.update_cal_doc(doc, base_doc_frs5)
cal_frs = FrsCalc(frs_doc)
uncert = FrsUncert(frs_doc)
cal_frs.temperature(res)
cal_frs.pressure_res(res)
cal_frs.pressure_cal(res)
uncert.total_standard(res, no_type_a=True)
p_1 = res.pick("Pressure", "cal", unit)
u_p_1 = res.pick("Uncertainty", "standard", "1")
res.store("Pressure", "cal", p_1, unit)
res.store("Uncertainty", "cal", u_p_1 * p_1, unit)
## -------------------------
## p_nd
## -------------------------
pres = Pressure(doc)
auxval = AuxValues(doc)
time = Time(doc)
p_nd_offset_before = auxval.get_value("nd_offset_before", "mbar")
p_nd_offset_after = auxval.get_value("nd_offset_after", "mbar")
if p_nd_offset_after:
p_nd_offset = (p_nd_offset_before + p_nd_offset_after) / 2
else:
p_nd_offset = p_nd_offset_before
p_nd_ind = pres.get_value("nd_ind", "mbar")
conv = const.get_conv(from_unit="mbar", to_unit=unit)
p_nd = (p_nd_ind - p_nd_offset) * conv
CustomerDevice = Cdg(doc, io.get_doc_db("cob-cdg-nd_se3"))
u_p_nd = CustomerDevice.get_total_uncert(p_nd_ind,
unit,
unit,
skip_type="A")
res.store("Pressure", "nd_corr", p_nd, unit)
res.store("Uncertainty", "nd_corr", u_p_nd, unit)
## -------------------------
# Unsicherheit Ausgasung:
## -------------------------
p_rise_rate = 3e-8 #Pa/s gemessen: 2019-01-18 08:40:27 (s. state docs)
t = time.get_rmt("amt_meas", "ms")
conv = const.get_conv(from_unit="ms", to_unit="s")
p_rise = p_rise_rate * t * conv
u_p_rise = 0.2 # Druckanstieg 20% Unsicher
res.store("Pressure", "rise", p_rise, unit)
res.store("Uncertainty", "rise", p_rise * u_p_rise / p_1, "1")
## -------------------------
# f:
## -------------------------
p_a = p_1 - p_nd + p_rise
p_b = p_0 * rg * dh
n = len(p_a)
x = np.full(n, 0.0)
y = np.full(n, 0.0)
for i in range(n):
# y[i] = p_a[i]/p_b[i]*T_0[i]/T_1[i] ## okish
if i == 0:
y[i] = p_a[i]
x[i] = p_b[i] * T_0[i] / T_1[i]
else:
#x[i] = p_a[i - 1]/T_1[i -1]*T_0[i]/p_0[i] ## okish
y[i] = p_a[i] - p_a[i - 1] * T_1[i] / T_1[i - 1]
x[i] = p_b[i] * T_1[i] / T_0[i] - p_a[i - 1] * T_1[i] / T_1[i -
1]
f = y / x
f = np.delete(f, f.argmin())
f = np.delete(f, f.argmax())
print(np.mean(f))
print(np.std(f) / np.mean(f))
## -------------------------
# save
## -------------------------
io.save_doc(res.build_doc())
