def increment(self, v):
if v >= 0:
self._increment = v
self.step = alphas(v)
else:
self._increment = -1
self.step = ''
def test_a_zz(self):
ints = range(26 + 26**2)
ass = [alphas(i) for i in ints]
seeds = string.ascii_uppercase
ALPHAS = [a for a in seeds
] + ['{}{}'.format(a, b) for a in seeds for b in seeds]
self.assertListEqual(ass, ALPHAS)
def _add_level(self):
irrad = self.irradiation
db = self.db
irrad = db.get_irradiation(irrad)
if irrad.levels:
level = irrad.levels[-1]
self.z = level.z or 0
if level.holder:
self.selected_tray = next(
(t for t in self.trays if t == level.holder), '')
nind = alpha_to_int(level.name) + 1
self.name = alphas(nind)
av = AddView(model=self)
info = av.edit_traits()
while 1:
if info.result:
for attr, msg in (
('name',
'No name enter for this level. Would you like to enter one?'
),
('selected_production',
'No Production Ratios selected for this level. Would you like to select one?'
),
('selected_tray',
'No tray selected for this level. Would like to select one?'
)):
info = self._check_attr_set(av, attr, msg)
if info == 'break':
break
elif info is not None:
continue
if not next(
(li for li in irrad.levels if li.name == self.name), None):
if self._save_level():
return self.name
else:
break
else:
self.warning_dialog(
'Level {} already exists for Irradiation {}'.format(
self.name, self.irradiation))
else:
break
def make_equation(self):
"""
y=Ax+B
y=Ax2+Bx+C
"""
n = len(self.coefficients) - 1
constant = alphas(n)
ps = []
for i in range(n):
a = alphas(i)
e = n - i
if e > 1:
a = '{}x{}'.format(a, e)
else:
a = '{}x'.format(a)
ps.append(a)
fit = self.fit
eq = '+'.join(ps)
s = '{}({}) y={}+{}'.format(fit, self.error_calc_type or 'CI', eq,
constant)
return s
def tostring(self, sig_figs=5):
cs = self.coefficients[::-1]
ce = self.coefficient_errors[::-1]
coeffs = []
for i, (ci, ei) in enumerate(zip(cs, ce)):
pp = '({})'.format(self.format_percent_error(ci, ei))
fmt = '{{:0.{}e}}' if abs(ci) < math.pow(
10, -sig_figs) else '{{:0.{}f}}'
ci = fmt.format(sig_figs).format(ci)
fmt = '{{:0.{}e}}' if abs(ei) < math.pow(
10, -sig_figs) else '{{:0.{}f}}'
ei = fmt.format(sig_figs).format(ei)
vfmt = u'{{}}= {{}} {} {{}} {{}}'.format(PLUSMINUS)
coeffs.append(vfmt.format(alphas(i), ci, ei, pp))
s = u', '.join(coeffs)
return s
def _get_step(self):
return alphas(self._step)
def make_step(s):
if isinstance(s, (float, int, int)):
s = alphas(s)
return s or ''
def test_a(self):
self.assertEqual(alphas(0), 'A')
def test_reciprocal6(self):
self.assertEqual(alphas(alpha_to_int('ZZZZ')), 'ZZZZ')
def test_reciprocal5(self):
self.assertEqual(alphas(alpha_to_int('AAA')), 'AAA')
def test_reciprocal4(self):
self.assertEqual(alphas(alpha_to_int('BA')), 'BA')
def step(self):
print(self.increment, alphas(self.increment))
return alphas(self.increment)
def test_ab(self):
self.assertEqual(alphas(27), 'AB')
def test_aa(self):
self.assertEqual(alphas(26), 'AA')
def test_z(self):
self.assertEqual(alphas(25), 'Z')
def _get_step(self):
return alphas(self.step_id - 1)
def _get_step_id_text(self):
return alphas(self.item.step_id - 1)
def _get_plateau_age(self):
ans = self.analyses
v, e = 0, 0
self.plateau_steps = None
self.plateau_steps_str = ''
self.nsteps = 0
self.plateau_mswd = 0
self.plateau_mswd_valid = False
if all((not isinstance(ai, InterpretedAgeGroup) for ai in ans)):
if ans:
ages = [ai.age for ai in ans]
errors = [ai.age_err for ai in ans]
k39 = [
nominal_value(ai.get_computed_value('k39')) for ai in ans
]
options = {
'nsteps': self.plateau_nsteps,
'gas_fraction': self.plateau_gas_fraction,
'overlap_sigma': self.plateau_overlap_sigma,
'fixed_steps': self.fixed_steps
}
excludes = [i for i, ai in enumerate(ans) if ai.is_omitted()]
args = calculate_plateau_age(ages,
errors,
k39,
method=self.plateau_method,
options=options,
excludes=excludes)
if args:
v, e, pidx = args
if pidx[0] == pidx[1]:
return
self.plateau_steps = pidx
self.plateau_steps_str = '{}-{}'.format(
alphas(pidx[0]), alphas(pidx[1]))
step_idxs = [
i for i in range(pidx[0], pidx[1] + 1)
if not ans[i].is_omitted()
]
self.nsteps = len(step_idxs)
pages = array([ages[i] for i in step_idxs])
perrs = array([errors[i] for i in step_idxs])
mswd = calculate_mswd(pages, perrs)
self.plateau_mswd_valid = validate_mswd(mswd, self.nsteps)
self.plateau_mswd = mswd
if self.plateau_age_error_kind == SD:
e = array(pages).std()
else:
e = self._modify_error(v,
e,
self.plateau_age_error_kind,
mswd=mswd)
if math.isnan(e):
e = 0
a = ufloat(v, max(0, e))
self._apply_j_err(a,
force=self.include_j_error_in_mean
or self.include_j_error_in_plateau)
return a
def test_reciprocal2(self):
self.assertEqual(alphas(alpha_to_int('C')), 'C')
