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 get_deadtime_vs_mswd(self):
taus = list(range(1, 20, 1))
ms = []
for tau in taus:
ns, ys, es = self.get_mean_raw(tau)
ms.append(calculate_mswd(ys, es))
return taus, ms
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 __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 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 __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 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 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 _validate_mswd(self, kind, unks, attr):
if attr == 'age':
xs = [u.age for u in unks]
es = [u.age_err_wo_j for u in unks]
elif attr == 'kca':
vs = [u.kca for u in unks]
xs = [nominal_value(v) for v in vs]
es = [std_dev(v) for v in vs]
mswd = calculate_mswd(xs, es)
if kind == 'mahon':
v = validate_mswd(mswd, len(xs))
elif kind == 'threshold':
v = mswd < self.mswd_threshold
else:
v = abs(mswd -
self._prev_mswd) / mswd * 100 < self.plateau_threshold
self._prev_mswd = mswd
return v
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
print 'uncorrected ratio {} = {:0.2f} '.format(i, m1)
for tau in taus:
# print 'calculating for dt= ', tau
for k in KEYS36:
d._correct_for_deadtime(nshots, k, tau / 1e9)
x = range(1, 6)
ratios1 = []
errs1 = []
for i in KEYS:
m1, e1 = d._calculate_mean_ratio(nshots[i + '40'], nshots[i + '36cor'])
ratios1.append(m1)
errs1.append(e1)
ms1 = calculate_mswd(ratios1, errs1)
mswds1.append(ms1)
rratios1.append(ratios1)
if tau % 5 == 0:
g.new_series(x, ratios1, plotid=1, type='line')
i = int((tau / 5) - 1)
# g.set_series_label('p', plotid=1, series=i)
# g.set_series_label('{} (ns)'.format(tau), plotid=1, series=i)
# g.plots[1].legend.plots = dict([(k, v[0]) for k, v in g.plots[1].plots.iteritems()])
# print g.plots[1].legend.plots
g.new_series(taus, mswds1, plotid=0, type='line_scatter')
def mcalculate_mswd(d):
return calculate_mswd(*d)
def mcalculate_mswd(d):
return calculate_mswd(*d)
