def calc_j(ai):
ar40=ai.get_interference_corrected_value('Ar40')
ar39=ai.get_interference_corrected_value('Ar39')
# ar40 = ai.isotopes['Ar40'].get_interference_corrected_value()
# ar39 = ai.isotopes['Ar39'].get_interference_corrected_value()
return calculate_flux(ar40, ar39, monitor_age)
def _make_flux_row(self, ans):
mR = sum(ai.R for ai in ans) / len(ans)
j, e = calculate_flux(mR, 1, self.monitor_age)
r = Row(fontsize=8)
r.add_item(value='<b>J</b>', span=5)
r.add_item(value='<b>{}</b>'.format(floatfmt(j)))
r.add_item(value='<b>{}</b>'.format(floatfmt(e)))
return r
def _make_flux_row(self, ans):
mR = sum(ai.R for ai in ans) / len(ans)
j, e = calculate_flux(mR, 1, self.monitor_age)
r = Row(fontsize=8)
r.add_item(value='<b>J</b>', span=5)
r.add_item(value='<b>{}</b>'.format(floatfmt(j)))
r.add_item(value='<b>{}</b>'.format(floatfmt(e)))
return r
def mean_j(ans):
ufs = (ai.uF for ai in ans)
fs, es = zip(*((fi.nominal_value, fi.std_dev) for fi in ufs))
av, werr = calculate_weighted_mean(fs, es)
if error_kind == 'SD':
n = len(fs)
werr = (sum((av - fs)**2) / (n - 1))**0.5
elif error_kind == 'SEM, but if MSWD>1 use SEM * sqrt(MSWD)':
mswd = calculate_mswd(fs, es)
werr *= (mswd**0.5 if mswd > 1 else 1)
# reg.trait_set(ys=fs, yserr=es)
# uf = (reg.predict([0]), reg.predict_error([0]))
uf = (av, werr)
return ufloat(*calculate_flux(uf, monitor_age))
def mean_j(ans):
ufs = (ai.uF for ai in ans)
fs, es = zip(*((fi.nominal_value, fi.std_dev)
for fi in ufs))
av, werr = calculate_weighted_mean(fs, es)
if error_kind == 'SD':
n = len(fs)
werr = (sum((av - fs) ** 2) / (n - 1)) ** 0.5
elif error_kind == 'SEM, but if MSWD>1 use SEM * sqrt(MSWD)':
mswd = calculate_mswd(fs, es)
werr *= (mswd ** 0.5 if mswd > 1 else 1)
# reg.trait_set(ys=fs, yserr=es)
# uf = (reg.predict([0]), reg.predict_error([0]))
uf = (av, werr)
return ufloat(*calculate_flux(uf, monitor_age))
def omean_j(ans, error_kind, monitor_age, lambda_k):
fs = [nominal_value(ai.uF) for ai in ans]
es = [std_dev(ai.uF) for ai in ans]
av, werr = calculate_weighted_mean(fs, es)
if error_kind == SD:
n = len(fs)
werr = (sum((av - fs) ** 2) / (n - 1)) ** 0.5
elif error_kind == MSEM:
mswd = calculate_mswd(fs, es)
werr *= (mswd ** 0.5 if mswd > 1 else 1)
uf = (av, werr)
j = calculate_flux(uf, monitor_age, lambda_k=lambda_k)
mswd = calculate_mswd(fs, es)
return j, mswd
def mean_j(ans, use_weights, error_kind, monitor_age, lambda_k):
js = [calculate_flux(ai.uF, monitor_age, lambda_k=lambda_k) for ai in ans]
fs = [nominal_value(fi) for fi in js]
es = [std_dev(fi) for fi in js]
if use_weights:
klass = WeightedMeanRegressor
else:
klass = MeanRegressor
reg = klass(ys=fs, yserr=es, error_calc_type=error_kind)
reg.calculate()
av = reg.predict()
werr = reg.predict_error(1)
j = ufloat(av, werr)
return j, reg.mswd
def mean_j(ans, error_kind, monitor_age, lambda_k):
# ufs = (ai.uF for ai in ans)
# fs, es = zip(*((fi.nominal_value, fi.std_dev)
# for fi in ufs))
fs = [nominal_value(ai.uF) for ai in ans]
es = [std_dev(ai.uF) for ai in ans]
av, werr = calculate_weighted_mean(fs, es)
if error_kind == 'SD':
n = len(fs)
werr = (sum((av - fs)**2) / (n - 1))**0.5
elif error_kind == 'SEM, but if MSWD>1 use SEM * sqrt(MSWD)':
mswd = calculate_mswd(fs, es)
werr *= (mswd**0.5 if mswd > 1 else 1)
# reg.trait_set(ys=fs, yserr=es)
# uf = (reg.predict([0]), reg.predict_error([0]))
uf = (av, werr)
j = calculate_flux(uf, monitor_age, lambda_k=lambda_k)
# print age_equation(j, uf, lambda_k=lambda_k, scalar=1)
return j
def mean_j(ans, error_kind, monitor_age, lambda_k):
# ufs = (ai.uF for ai in ans)
# fs, es = zip(*((fi.nominal_value, fi.std_dev)
# for fi in ufs))
fs = [nominal_value(ai.uF) for ai in ans]
es = [std_dev(ai.uF) for ai in ans]
av, werr = calculate_weighted_mean(fs, es)
if error_kind == 'SD':
n = len(fs)
werr = (sum((av - fs) ** 2) / (n - 1)) ** 0.5
elif error_kind == 'SEM, but if MSWD>1 use SEM * sqrt(MSWD)':
mswd = calculate_mswd(fs, es)
werr *= (mswd ** 0.5 if mswd > 1 else 1)
# reg.trait_set(ys=fs, yserr=es)
# uf = (reg.predict([0]), reg.predict_error([0]))
uf = (av, werr)
j = calculate_flux(uf, monitor_age, lambda_k=lambda_k)
# print age_equation(j, uf, lambda_k=lambda_k, scalar=1)
return j
def mean_j(ans, error_kind, monitor_age, lambda_k):
js = [calculate_flux(ai.uF, monitor_age, lambda_k=lambda_k) for ai in ans]
fs = [nominal_value(fi) for fi in js]
es = [std_dev(fi) for fi in js]
av, werr = calculate_weighted_mean(fs, es)
mswd = None
if error_kind == SD:
n = len(fs)
werr = (sum((av - fs) ** 2) / (n - 1)) ** 0.5
elif error_kind == MSEM:
mswd = calculate_mswd(fs, es)
werr *= (mswd ** 0.5 if mswd > 1 else 1)
j = ufloat(av, werr)
if mswd is None:
mswd = calculate_mswd(fs, es)
return j, mswd
def model_j(self, monitor_age, lambda_k):
j = calculate_flux(self.uF, monitor_age, lambda_k=lambda_k)
return j
def _rebuild_graph(self):
g = self.graph
g.clear()
plot1 = g.new_plot(ytitle='Delta Age (ka)',
xtitle='Time (s)',
padding_left=70,
padding_right=25
)
plot2 = g.new_plot(ytitle='Ar39 (fA)',
padding_left=70,
padding_right=25
)
plot3 = g.new_plot(ytitle='Ar40 (fA)',
padding_left=70,
padding_right=25
)
Ar40 = self.Ar40.intensity
Ar39 = self.Ar39.intensity
if not (Ar40 and Ar39):
return
plot2.value_range.low_setting = Ar39 * .95
plot2.value_range.high_setting = Ar39 * 1.05
plot3.value_range.low_setting = Ar40 * .95
plot3.value_range.high_setting = Ar40 * 1.01
R = Ar40 / Ar39
xma = self.max_time
rs = []
ns = []
ds = []
if self.vary_time_zero:
posts = (15,)
xs = list(range(0, 15))
index = xs
else:
posts = list(range(5, 30))
xs = (0,)
index = posts
for pi in posts:
for ti in xs:
# subplot(311)
n = self.calc_intercept(Ar40, pi,
self.Ar40.equil_rate,
self.Ar40.static_rate,
xma, 2,
time_zero=ti
)
# subplot(312)
d = self.calc_intercept(Ar39, pi,
self.Ar39.equil_rate,
self.Ar39.static_rate,
xma, 1,
time_zero=ti)
ns.append(n)
ds.append(d)
# rs.append(((n / d) - R) / R * 100)
rs.append((n / d))
# print ns
# g.new_series(xs, ns, plotid=2)
# g.new_series(xs, ds, plotid=1)
# g.new_series(to, rs, plotid=0)
mon_age = 28
j = calculate_flux((Ar40, 0), (Ar39, 0), mon_age)
ages = [(age_equation(j[0], abs(ri)) - mon_age) * 1000 for ri in rs]
g.new_series(index, ages, plotid=0)
def _rebuild_graph(self):
g = self.graph
g.clear()
plot1 = g.new_plot(ytitle='Delta Age (ka)',
xtitle='Time (s)',
padding_left=70,
padding_right=25)
plot2 = g.new_plot(ytitle='Ar39 (fA)',
padding_left=70,
padding_right=25)
plot3 = g.new_plot(ytitle='Ar40 (fA)',
padding_left=70,
padding_right=25)
Ar40 = self.Ar40.intensity
Ar39 = self.Ar39.intensity
if not (Ar40 and Ar39):
return
plot2.value_range.low_setting = Ar39 * .95
plot2.value_range.high_setting = Ar39 * 1.05
plot3.value_range.low_setting = Ar40 * .95
plot3.value_range.high_setting = Ar40 * 1.01
R = Ar40 / Ar39
xma = self.max_time
rs = []
ns = []
ds = []
if self.vary_time_zero:
posts = (15, )
xs = range(0, 15)
index = xs
else:
posts = range(5, 30)
xs = (0, )
index = posts
for pi in posts:
for ti in xs:
# subplot(311)
n = self.calc_intercept(Ar40,
pi,
self.Ar40.equil_rate,
self.Ar40.static_rate,
xma,
2,
time_zero=ti)
# subplot(312)
d = self.calc_intercept(Ar39,
pi,
self.Ar39.equil_rate,
self.Ar39.static_rate,
xma,
1,
time_zero=ti)
ns.append(n)
ds.append(d)
# rs.append(((n / d) - R) / R * 100)
rs.append((n / d))
# print ns
# g.new_series(xs, ns, plotid=2)
# g.new_series(xs, ds, plotid=1)
# g.new_series(to, rs, plotid=0)
mon_age = 28
j = calculate_flux((Ar40, 0), (Ar39, 0), mon_age)
ages = [(age_equation(j[0], abs(ri)) - mon_age) * 1000 for ri in rs]
g.new_series(index, ages, plotid=0)
def model_j(self, monitor_age, lambda_k):
j = calculate_flux(self.uF, monitor_age, lambda_k=lambda_k)
return j
def calc_j(ai):
ar40 = ai.arar_result['rad40']
ar39 = ai.arar_result['k39']
return calculate_flux(ar40, ar39, monitor_age)
def calc_j(ai):
ar40 = ai.arar_result['rad40']
ar39 = ai.arar_result['k39']
return calculate_flux(ar40, ar39, monitor_age)
