def get_mean_raw(self, tau=None):
vs = []
corrfunc = self._deadtime_correct
for r in six.itervalues(self._cp):
n = int(r['NShots'])
nv = ufloat(float(r['Ar40']), float(r['Ar40err'])) * 6240
dv = ufloat(float(r['Ar36']), float(r['Ar36err'])) * 6240
if tau:
dv = corrfunc(dv, tau * 1e-9)
vs.append((n, nv / dv))
key = lambda x: x[0]
vs = sorted(vs, key=key)
mxs = []
mys = []
mes = []
for n, gi in groupby(vs, key=key):
mxs.append(n)
ys, es = list(zip(*[(nominal_value(xi[1]), std_dev(xi[1])) for xi in gi]))
wm, werr = calculate_weighted_mean(ys, es)
mys.append(wm)
mes.append(werr)
return mxs, mys, mes
def calculate(self):
total = len(self.records)
if not total:
return
data = [(a.age, a.age_err) for a in self.records if a.status]
if not data:
return
data = array(data)
x, errs = data.T
self.mean = x.mean()
self.std = x.std()
self.n = n = len(x)
self.weighted_mean, self.weighted_mean_err = calculate_weighted_mean(
x, errs)
self.mean = sum(x) / n
self.mswd = calculate_mswd(x, errs, wm=self.weighted_mean)
self.min = min(x)
self.max = max(x)
self.dev = self.max - self.min
try:
self.percent_dev = self.dev / self.max * 100
except ZeroDivisionError:
self.percent_dev = 0
self.displayn = '{}'.format(n)
if total > n:
self.displayn = '{}/{}'.format(n, total)
def _calculate_mean_ratio(self, s40, s36):
r = [i40 / i36 for i40, i36 in zip(s40, s36)]
v = [vi.nominal_value for vi in r]
errs = [vi.std_dev for vi in r]
m, e = calculate_weighted_mean(v, errs)
return m, e
def __init__(self, ratios, name, *args, **kw):
super(Result, self).__init__(*args, **kw)
vs = array([nominal_value(ri) for ri in ratios])
es = array([std_dev(ri) for ri in ratios])
self.name = name
m = ratios.mean()
self.value = nominal_value(m)
self.error = std_dev(m)
wm, we = calculate_weighted_mean(vs, es)
self.wm_value = wm
self.wm_error = we
self.mswd = calculate_mswd(vs, es, wm=wm)
def __init__(self, ratios, name, *args, **kw):
super(Result, self).__init__(*args, **kw)
vs = array([nominal_value(ri) for ri in ratios])
es = array([std_dev(ri) for ri in ratios])
self.name = name
m = ratios.mean()
self.value = nominal_value(m)
self.error = std_dev(m)
wm, we = calculate_weighted_mean(vs, es)
self.wm_value = wm
self.wm_error = we
self.mswd = calculate_mswd(vs, es, wm=wm)
def _write_summary_sheet(self, ias, title, adapter, options):
# def set_nsigma(nattr):
# def f(item, attr):
# return getattr(item, attr) * getattr(self.options,
# '{}_nsigma'.format(nattr))
#
# return f
sh = self._workbook.add_worksheet('Summary')
if options:
sh.show_grid = options.show_grid
sh.show_outline = options.show_outline
# cols = [('Sample', 'sample'),
# ('Identifier', 'identifier'),
# ('Irradiation', 'irradiation'),
# ('Material', 'material'),
# ('Age Type', 'age_kind'),
# ('MSWD', 'mswd'),
# ('N', 'nanalyses'),
# ('K/Ca', 'kca'),
# # (u'{}\u03c3'.format(self.options.kca_nsigma),
# # 'kca_err', set_nsigma('kca')),
#
# ('Age', 'display_age'),
# # (u'{}\u03c3'.format(self.options.age_nsigma),
# # 'age_err', set_nsigma('age')),
# ]
cols = adapter.columns
start = 0
if title:
self._add_title_row(0, sh, title)
start = 1
self._add_summary_header_row(start, sh, cols)
start += 2
for i, ia in enumerate(ias):
r = i + start
self._add_summary_row(sh, ia, r, cols, adapter)
if options.include_weighted_mean:
vs, es = list(
zip(*((ia.age, ia.age_err) for ia in ias
if not ia.is_omitted())))
wm, we = calculate_weighted_mean(vs, es)
print(wm, we)
sh.write(r + 2, 0, 'Weighted Mean')
sh.write(r + 2, 2, wm)
sh.write(r + 2, 3, we)
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 _write_summary_sheet(self, ias, title, adapter, options):
# def set_nsigma(nattr):
# def f(item, attr):
# return getattr(item, attr) * getattr(self.options,
# '{}_nsigma'.format(nattr))
#
# return f
sh = self._workbook.add_worksheet('Summary')
if options:
sh.show_grid = options.show_grid
sh.show_outline = options.show_outline
# cols = [('Sample', 'sample'),
# ('Identifier', 'identifier'),
# ('Irradiation', 'irradiation'),
# ('Material', 'material'),
# ('Age Type', 'age_kind'),
# ('MSWD', 'mswd'),
# ('N', 'nanalyses'),
# ('K/Ca', 'kca'),
# # (u'{}\u03c3'.format(self.options.kca_nsigma),
# # 'kca_err', set_nsigma('kca')),
#
# ('Age', 'display_age'),
# # (u'{}\u03c3'.format(self.options.age_nsigma),
# # 'age_err', set_nsigma('age')),
# ]
cols = adapter.columns
start = 0
if title:
self._add_title_row(0, sh, title)
start = 1
self._add_summary_header_row(start, sh, cols)
start += 2
for i, ia in enumerate(ias):
r = i + start
self._add_summary_row(sh, ia, r, cols, adapter)
if options.include_weighted_mean:
vs, es = list(zip(*((ia.age, ia.age_err) for ia in ias if not ia.is_omitted())))
wm, we = calculate_weighted_mean(vs, es)
print(wm, we)
sh.write(r + 2, 0, 'Weighted Mean')
sh.write(r + 2, 2, wm)
sh.write(r + 2, 3, we)
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 calculate(self):
total = len(self.records)
data = array([(a.age, a.age_err) for a in self.records if a.status])
x, errs = data.T
self.mean = x.mean()
self.std = x.std()
self.n = n = len(x)
self.weighted_mean, self.weighted_mean_err = calculate_weighted_mean(
x, errs)
self.mean = sum(x) / n
self.mswd = calculate_mswd(x, errs, self.weighted_mean)
self.displayn = '{}'.format(n)
if total > n:
self.displayn = '{}/{}'.format(n, total)
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, 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 _plot_radial(self, po, plot, pid):
zs = array([nominal_value(a.uage) for a in self.analyses])
es = array([std_dev(a.uage) for a in self.analyses])
zm, _ = calculate_weighted_mean(zs, es)
zs = (zs - zm) / es
yma = max(abs(zs))
es = 1 / es
# xs = array([1/std_dev(a.uage) for a in self.analyses])
# ys = array([nominal_value(a.uage)/(std_dev(a.uage)) for a in self.analyses])
try:
self.ymis[pid] = min(self.ymis[pid], -yma)
self.ymas[pid] = max(self.ymas[pid], yma)
except IndexError:
self.ymis.append(-yma)
self.ymas.append(yma)
# overlay = RadialOverlay(plot, xs=xs, ys=ys)
# plot.overlays.append(overlay)
s, _ = self.graph.new_series(es, zs, type='scatter')
self._add_scatter_inspector(s)
self.graph.set_x_limits(min_=0)
def _plot_radial(self, po, plot, pid):
zs = array([nominal_value(a.uage) for a in self.analyses])
es = array([std_dev(a.uage) for a in self.analyses])
zm,_ = calculate_weighted_mean(zs, es)
zs = (zs - zm)/es
yma = max(abs(zs))
es = 1/es
# xs = array([1/std_dev(a.uage) for a in self.analyses])
# ys = array([nominal_value(a.uage)/(std_dev(a.uage)) for a in self.analyses])
try:
self.ymis[pid] = min(self.ymis[pid], -yma)
self.ymas[pid] = max(self.ymas[pid], yma)
except IndexError:
self.ymis.append(-yma)
self.ymas.append(yma)
# overlay = RadialOverlay(plot, xs=xs, ys=ys)
# plot.overlays.append(overlay)
s, _ = self.graph.new_series(es, zs, type='scatter')
self._add_scatter_inspector(s)
self.graph.set_x_limits(min_=0)
