def make_statistics(reg, x=None):
v, e = reg.predict(0), reg.predict_error(0)
lines = [reg.make_equation(),
'x=0, y={} {}{}({}%)'.format(floatfmt(v, n=6),
PLUSMINUS,
floatfmt(e, n=6),
format_percent_error(v, e))]
if x is not None:
vv, ee = reg.predict(x), reg.predict_error(x)
lines.append('x={}, y={} +/-{}({}%)'.format(x, floatfmt(vv, n=6),
floatfmt(ee, n=6),
format_percent_error(vv, ee)))
if reg.mswd not in ('NaN', None):
valid = '' if reg.valid_mswd else '*'
lines.append('MSWD= {}{}, N={}'.format(valid,
floatfmt(reg.mswd, n=3), reg.n))
mi, ma = reg.min, reg.max
lines.append('Min={}, Max={}, Dev={}%'.format(floatfmt(mi),
floatfmt(ma),
floatfmt((ma - mi) / ma * 100, n=2)))
lines.append('Mean={}, SD={}, SEM={}, N={}'.format(floatfmt(reg.mean), floatfmt(reg.std),
floatfmt(reg.sem), reg.n))
if not isinstance(reg, MeanRegressor):
lines.append('R\u00b2={}, R\u00b2-Adj.={}'.format(floatfmt(reg.rsquared), floatfmt(reg.rsquared_adj)))
lines.extend([l.strip() for l in reg.tostring().split(',')])
return lines
def _build_label_text(self, x, we, mswd, valid_mswd, n,
percent_error=False,
sig_figs=3):
display_n = True
display_mswd = n >= 2
if display_n:
n = 'n= {}'.format(n)
else:
n = ''
if display_mswd:
vd = '' if valid_mswd else '*'
mswd = '{}mswd= {:0.2f}'.format(vd, mswd)
else:
mswd = ''
sx = floatfmt(x, sig_figs)
swe = floatfmt(we, sig_figs)
if self.options.index_attr in ('uF', 'Ar40/Ar36'):
me = '{} +/-{}'.format(sx, swe)
else:
age_units = self._get_age_units()
pe = ''
if percent_error:
pe = '({})'.format(format_percent_error(x, we, include_percent_sign=True))
me = '{} +/-{}{} {}'.format(sx, swe, pe, age_units)
return u'{} {} {}'.format(me, mswd, n)
def load_measurement(self, an, ar):
j = self._get_j(an)
jf = 'NaN'
if j is not None:
jj = floatfmt(j.nominal_value, n=7, s=5)
pe = format_percent_error(j.nominal_value,
j.std_dev,
include_percent_sign=True)
jf = u'{} \u00b1{:0.2e}({})'.format(jj, j.std_dev, pe)
a39 = ar.ar39decayfactor
a37 = ar.ar37decayfactor
ms = [
MeasurementValue(name='DR Version', value=an.data_reduction_tag),
MeasurementValue(name='DAQ Version', value=an.collection_version),
MeasurementValue(name='AnalysisID', value=self.analysis_id),
MeasurementValue(name='Spectrometer', value=an.mass_spectrometer),
MeasurementValue(name='Run Date',
value=an.rundate.strftime('%Y-%m-%d %H:%M:%S')),
MeasurementValue(name='Irradiation',
value=self._get_irradiation(an)),
MeasurementValue(name='J', value=jf),
MeasurementValue(name='Project', value=an.project),
MeasurementValue(name='Sample', value=an.sample),
MeasurementValue(name='Material', value=an.material),
MeasurementValue(name='Comment', value=an.comment),
MeasurementValue(name='Ar39Decay', value=floatfmt(a39)),
MeasurementValue(name='Ar37Decay', value=floatfmt(a37)),
MeasurementValue(name='Sens.', value=floatfmt(an.sensitivity))
]
self.measurement_values = ms
def _load_air_computed(self, an, new_list):
if self.experiment_type == AR_AR:
if new_list:
c = an.arar_constants
ratios = [('40Ar/36Ar', 'Ar40/Ar36', nominal_value(c.atm4036)),
('40Ar/38Ar', 'Ar40/Ar38', nominal_value(c.atm4038))]
cv = self._make_ratios(ratios)
self.computed_values = cv
self._update_ratios()
try:
niso, diso = self._get_ratio('Ar40/Ar36')
if niso and diso:
noncorrected = self._get_non_corrected_ratio(niso, diso)
v, e = nominal_value(noncorrected), std_dev(noncorrected)
ref = 295.5
self.summary_str = u'Ar40/Ar36={} {}{}({}%) IC={:0.5f}'.format(
floatfmt(v), PLUSMINUS, floatfmt(e),
format_percent_error(v, e),
nominal_value(noncorrected / ref))
except:
pass
else:
# todo add ratios for other isotopes. e.g Ne
pass
def func(ai):
uv = ai.get_value(i_attr)
v = nominal_value(uv)
e = std_dev(uv)
pe = format_percent_error(v, e)
return '{}= {}+/-{}({}%)'.format(fi_attr, floatfmt(v), floatfmt(e),
pe)
def _add_info(self, plot, reg, label=None, text_color='black'):
intercept = reg.predict(0)
err = reg.get_intercept_error()
mswd = reg.mswd
n = reg.n
try:
inv_intercept = intercept ** -1
p = calc_percent_error(intercept, err, scale=1)
err = inv_intercept * p
mse = err * mswd ** 0.5
v, e, p, mse = floatfmt(inv_intercept, s=3), floatfmt(err, s=3), floatfmt(p * 100, n=2), floatfmt(mse, s=3)
except ZeroDivisionError:
v, e, p, mse = 'NaN', 'NaN', 'NaN', 'NaN'
ratio_line = u'Ar40/Ar36= {} {}{} ({}%) mse= {}'.format(v, PLUSMINUS, e, p, mse)
u = self._ref_age_units
age = self.analysis_group.isochron_age
v = age.nominal_value
e = age.std_dev
p = format_percent_error(v, e)
mse_age = e * mswd ** 0.5
valid = validate_mswd(mswd, n)
mswd = '{:0.2f}'.format(mswd)
if not valid:
mswd = '*{}'.format(mswd)
# n = len([ai for ai in self.analyses if ai.temp_status == 0])
# mswd = 'NaN'
age_line = u'Age= {} {}{} ({}%) {}. mse= {}'.format(floatfmt(v, n=3),
PLUSMINUS,
floatfmt(e, n=4, s=3), p, u,
floatfmt(mse_age, s=3))
mswd_line = 'N= {} mswd= {}'.format(n, mswd)
if label is None:
th = 0
for overlay in plot.overlays:
if isinstance(overlay, OffsetPlotLabel):
w, h = overlay.get_preferred_size()
th += h + 2
label = OffsetPlotLabel(
offset=(1, th),
component=plot,
overlay_position='inside bottom',
hjustify='left',
bgcolor='white',
color=text_color)
plot.overlays.append(label)
self._plot_label = label
lines = u'\n'.join((ratio_line, age_line, mswd_line))
label.text = u'{}'.format(lines)
label.request_redraw()
def _build_label_text(self, x, we, n, total_n=None, mswd_args=None, percent_error=False, sig_figs=3):
display_n = True
display_mswd = n >= 2
if display_n:
if total_n and n != total_n:
n = "n= {}/{}".format(n, total_n)
else:
n = "n= {}".format(n)
else:
n = ""
if mswd_args and display_mswd:
mswd, valid_mswd, _ = mswd_args
vd = "" if valid_mswd else "*"
mswd = "{}mswd= {:0.2f}".format(vd, mswd)
else:
mswd = ""
sx = floatfmt(x, sig_figs)
swe = floatfmt(we, sig_figs)
if self.options.index_attr in ("uF", "Ar40/Ar36"):
me = u"{} {}{}".format(sx, PLUSMINUS, swe)
else:
age_units = self._get_age_units()
pe = ""
if percent_error:
pe = "({})".format(format_percent_error(x, we, include_percent_sign=True))
me = u"{} {}{}{} {}".format(sx, PLUSMINUS, swe, pe, age_units)
return u"{} {} {}".format(me, mswd, n)
def make_statistics(reg, x=None, options=None):
if options is None:
options = {}
display_min_max = options.get('display_min_max', True)
v, e = reg.predict(0), reg.predict_error(0)
lines = [
reg.make_equation(),
'x=0, y={} {}{}({}%)'.format(floatfmt(v, n=6), PLUSMINUS,
floatfmt(e, n=6),
format_percent_error(v, e))
]
if x is not None:
vv, ee = reg.predict(x), reg.predict_error(x)
lines.append('x={}, y={} +/-{}({}%)'.format(
x, floatfmt(vv, n=6), floatfmt(ee, n=6),
format_percent_error(vv, ee)))
if reg.mswd not in ('NaN', None):
lines.append('Fit MSWD= {}{}, N={}'.format(reg.format_mswd(),
floatfmt(reg.mswd, n=3),
reg.n))
if display_min_max:
mi, ma = reg.min, reg.max
lines.append('Min={}, Max={}, Dev={}%'.format(
floatfmt(mi), floatfmt(ma), floatfmt((ma - mi) / ma * 100, n=2)))
lines.append('Mean={}, SD={}, SEM={}, N={}'.format(floatfmt(reg.mean),
floatfmt(reg.std),
floatfmt(reg.sem),
reg.n))
mean_mswd = reg.mean_mswd
if mean_mswd is not None:
lines.append('Mean MSWD= {}'.format(reg.format_mswd(mean=True)))
# lines.append('Mean MSWD= {}{}'.format(valid, floatfmt(reg.mean_mswd, n=3)))
if not isinstance(reg, MeanRegressor):
lines.append('R\u00b2={}, R\u00b2-Adj.={}'.format(
floatfmt(reg.rsquared), floatfmt(reg.rsquared_adj)))
lines.extend([l.strip() for l in reg.tostring().split(',')])
return lines
def _load_unknown_computed(self, an, new_list):
attrs = (('Age', 'uage_w_j_err'),
# ('Age', 'age', None, None, 'age_err'),
('w/o J', 'wo_j', '', 'uage', 'age_err_wo_j'),
('K/Ca', 'kca'),
('K/Cl', 'kcl'),
('40Ar*', 'rad40_percent'),
('F', 'uF'),
('w/o Irrad', 'wo_irrad', '', 'uF', 'F_err_wo_irrad'))
if new_list:
def comp_factory(n, a, value=None, value_tag=None, error_tag=None):
if value is None:
value = getattr(an, a)
display_value = True
if value_tag:
value = getattr(an, value_tag)
display_value = False
if error_tag:
e = getattr(an, error_tag)
else:
e = std_dev(value)
return ComputedValue(name=n,
tag=a,
value=nominal_value(value) or 0,
value_tag=value_tag or '',
display_value=display_value,
error=e or 0)
cv = [comp_factory(*args)
for args in attrs]
self.computed_values = cv
else:
age = an.uage
nage, sage = nominal_value(age), std_dev(age)
try:
self.summary_str = u'Age={} {}{}({}%)'.format(floatfmt(nage), PLUSMINUS,
floatfmt(sage), format_percent_error(nage, sage))
except:
pass
for ci in self.computed_values:
attr = ci.tag
if attr == 'wo_j':
ci.error = an.age_err_wo_j or 0
ci.value = nominal_value(getattr(an, ci.value_tag))
elif attr == 'wo_irrad':
ci.error = an.F_err_wo_irrad or 0
ci.value = nominal_value(getattr(an, ci.value_tag))
else:
v = getattr(an, attr)
if v is not None:
ci.value = nominal_value(v)
ci.error = std_dev(v)
def _load_unknown_computed(self, an, new_list):
attrs = (('Age', 'uage_w_j_err'), ('w/o J', 'wo_j', '', 'uage',
'age_err_wo_j'), ('K/Ca', 'kca'),
('K/Cl', 'kcl'), ('40Ar*', 'radiogenic_yield'), ('F', 'uF'),
('w/o Irrad', 'wo_irrad', '', 'uF', 'F_err_wo_irrad'))
if new_list:
def comp_factory(n, a, value=None, value_tag=None, error_tag=None):
if value is None:
value = getattr(an, a)
display_value = True
if value_tag:
value = getattr(an, value_tag)
display_value = False
if error_tag:
e = getattr(an, error_tag)
else:
e = std_dev(value)
return self._computed_value_factory(
name=n,
tag=a,
value=nominal_value(value) or 0,
value_tag=value_tag or '',
display_value=display_value,
error=e or 0)
cv = [comp_factory(*args) for args in attrs]
self.computed_values = cv
else:
age = an.uage
nage, sage = nominal_value(age), std_dev(age)
try:
self.summary_str = u'Age={} {}{}({}%)'.format(
floatfmt(nage), PLUSMINUS, floatfmt(sage),
format_percent_error(nage, sage))
except:
pass
for ci in self.computed_values:
ci.sig_figs = self.sig_figs
attr = ci.tag
if attr == 'wo_j':
ci.error = an.age_err_wo_j or 0
ci.value = nominal_value(getattr(an, ci.value_tag))
elif attr == 'wo_irrad':
ci.error = an.F_err_wo_irrad or 0
ci.value = nominal_value(getattr(an, ci.value_tag))
else:
v = getattr(an, attr)
if v is not None:
ci.value = nominal_value(v)
ci.error = std_dev(v)
def value_string(self, t):
if t == 'uF':
a, e = self.F, self.F_err
elif t == 'uage':
a, e = self.uage.nominal_value, self.uage.std_dev
else:
v = self.get_value(t)
if isinstance(v, Isotope):
v = v.get_intensity()
a, e = v.nominal_value, v.std_dev
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def value_string(self, t):
if t == 'uF':
a, e = self.F, self.F_err
elif t == 'uage':
a, e = self.uage.nominal_value, self.uage.std_dev
else:
v = self.get_value(t)
if isinstance(v, Isotope):
v = v.get_intensity()
a, e = v.nominal_value, v.std_dev
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def load_measurement(self, an, ar):
# j = self._get_j(an)
j = ar.j
jf = 'NaN'
if j is not None:
jj = floatfmt(nominal_value(j), n=7, s=5)
pe = format_percent_error(nominal_value(j), std_dev(j), include_percent_sign=True)
jf = u'{} \u00b1{:0.2e}({})'.format(jj, std_dev(j), pe)
a39 = ar.ar39decayfactor
a37 = ar.ar37decayfactor
ms = [MeasurementValue(name='Branch',
value=an.branch),
MeasurementValue(name='DAQ Version',
value=an.collection_version),
MeasurementValue(name='UUID',
value=an.uuid),
MeasurementValue(name='RepositoryID',
value=an.repository_identifier),
MeasurementValue(name='Spectrometer',
value=an.mass_spectrometer),
MeasurementValue(name='Run Date',
value=an.rundate.strftime('%Y-%m-%d %H:%M:%S')),
MeasurementValue(name='Irradiation',
value=self._get_irradiation(an)),
MeasurementValue(name='J',
value=jf),
MeasurementValue(name='Position Error',
value=floatfmt(an.position_jerr, use_scientific=True)),
MeasurementValue(name='Lambda K',
value=nominal_value(ar.arar_constants.lambda_k),
units='1/a'),
MeasurementValue(name='Project',
value=an.project),
MeasurementValue(name='Sample',
value=an.sample),
MeasurementValue(name='Material',
value=an.material),
MeasurementValue(name='Comment',
value=an.comment),
MeasurementValue(name='Ar39Decay',
value=floatfmt(a39)),
MeasurementValue(name='Ar37Decay',
value=floatfmt(a37)),
MeasurementValue(name='Sens.',
value=floatfmt(an.sensitivity, use_scientific=True),
units=an.sensitivity_units)]
self.measurement_values = ms
def load_measurement(self, an, ar):
# j = self._get_j(an)
j = ar.j
jf = 'NaN'
if j is not None:
jj = floatfmt(nominal_value(j), n=7, s=5)
pe = format_percent_error(nominal_value(j),
std_dev(j),
include_percent_sign=True)
jf = u'{} \u00b1{:0.2e}({})'.format(jj, std_dev(j), pe)
a39 = ar.ar39decayfactor
a37 = ar.ar37decayfactor
ms = [
MeasurementValue(name='Branch', value=an.branch),
MeasurementValue(name='DAQ Version', value=an.collection_version),
MeasurementValue(name='UUID', value=an.uuid),
MeasurementValue(name='RepositoryID',
value=an.repository_identifier),
MeasurementValue(name='Spectrometer', value=an.mass_spectrometer),
MeasurementValue(name='Run Date',
value=an.rundate.strftime('%Y-%m-%d %H:%M:%S')),
MeasurementValue(name='Irradiation',
value=self._get_irradiation(an)),
MeasurementValue(name='J', value=jf),
MeasurementValue(name='Position Error',
value=floatfmt(an.position_jerr,
use_scientific=True)),
MeasurementValue(name='Lambda K',
value=nominal_value(ar.arar_constants.lambda_k),
units='1/a'),
MeasurementValue(name='Project', value=an.project),
MeasurementValue(name='Sample', value=an.sample),
MeasurementValue(name='Material', value=an.material),
MeasurementValue(name='Comment', value=an.comment),
MeasurementValue(name='Ar39Decay', value=floatfmt(a39)),
MeasurementValue(name='Ar37Decay', value=floatfmt(a37)),
MeasurementValue(name='K3739 Mode', value=an.display_k3739_mode),
MeasurementValue(name='Sens.',
value=floatfmt(an.sensitivity,
use_scientific=True),
units=an.sensitivity_units)
]
self.measurement_values = ms
def assemble_lines(self):
reg = self.component.regressor
v, e = reg.predict(0), reg.predict_error(0)
lines = [reg.make_equation(),
'x=0, y={} +/-{}({}%)'.format(floatfmt(v, n=5),
floatfmt(e, n=5),
format_percent_error(v, e))]
if not reg.mswd in ('NaN', None):
valid = '' if reg.valid_mswd else '*'
lines.append('MSWD= {}{}, n={}'.format(valid,
floatfmt(reg.mswd, n=3), reg.n))
lines.extend(map(unicode.strip, map(unicode, reg.tostring().split(','))))
return lines
def _build_label_text(self,
x,
we,
n,
total_n=None,
mswd_args=None,
display_n=True,
display_mswd=True,
percent_error=False,
sig_figs=3):
display_mswd = n >= 2 and display_mswd
if display_n:
if total_n and n != total_n:
n = 'n= {}/{}'.format(n, total_n)
else:
n = 'n= {}'.format(n)
else:
n = ''
if mswd_args and display_mswd:
mswd, valid_mswd, _ = mswd_args
vd = '' if valid_mswd else '*'
mswd = '{} MSWD= {:0.2f}'.format(vd, mswd)
else:
mswd = ''
sx = floatfmt(x, sig_figs)
swe = floatfmt(we, sig_figs)
if self.options.index_attr in ('uF', 'Ar40/Ar36'):
me = u'{} {}{}'.format(sx, PLUSMINUS, swe)
else:
age_units = self._get_age_units()
pe = ''
if percent_error:
pe = '({})'.format(
format_percent_error(x, we, include_percent_sign=True))
me = u'{} {}{}{} {}'.format(sx, PLUSMINUS, swe, pe, age_units)
return u'{} {} {}'.format(me, mswd, n)
def load_measurement(self, an, ar):
j = self._get_j(an)
jf = 'NaN'
if j is not None:
jj = floatfmt(j.nominal_value, n=7, s=5)
pe = format_percent_error(j.nominal_value, j.std_dev, include_percent_sign=True)
jf = u'{} \u00b1{:0.2e}({})'.format(jj, j.std_dev, pe)
a39 = ar.ar39decayfactor
a37 = ar.ar37decayfactor
ms = [
MeasurementValue(name='DR Version',
value=an.data_reduction_tag),
MeasurementValue(name='DAQ Version',
value=an.collection_version),
MeasurementValue(name='AnalysisID',
value=self.analysis_id),
MeasurementValue(name='Spectrometer',
value=an.mass_spectrometer),
MeasurementValue(name='Run Date',
value=an.rundate.strftime('%Y-%m-%d %H:%M:%S')),
MeasurementValue(name='Irradiation',
value=self._get_irradiation(an)),
MeasurementValue(name='J',
value=jf),
MeasurementValue(name='Project',
value=an.project),
MeasurementValue(name='Sample',
value=an.sample),
MeasurementValue(name='Material',
value=an.material),
MeasurementValue(name='Comment',
value=an.comment),
MeasurementValue(name='Ar39Decay',
value=floatfmt(a39)),
MeasurementValue(name='Ar37Decay',
value=floatfmt(a37)),
MeasurementValue(name='Sens.',
value=floatfmt(an.sensitivity))]
self.measurement_values = ms
def load_measurement(self, an, ar):
# j = self._get_j(an)
j = ar.j
jf = 'NaN'
if j is not None:
jj = floatfmt(nominal_value(j), n=7, s=5)
pe = format_percent_error(nominal_value(j),
std_dev(j),
include_percent_sign=True)
jf = u'{} \u00b1{:0.2e}({})'.format(jj, std_dev(j), pe)
a39 = ar.ar39decayfactor
a37 = ar.ar37decayfactor
ms = [
# MeasurementValue(name='DR Version',
# value=an.data_reduction_tag),
MeasurementValue(name='Branch', value=an.branch),
MeasurementValue(name='DAQ Version', value=an.collection_version),
MeasurementValue(name='ExperimentID',
value=an.repository_identifier),
# MeasurementValue(name='AnalysisID',
# value=self.analysis_ida),
MeasurementValue(name='Spectrometer', value=an.mass_spectrometer),
MeasurementValue(name='Run Date',
value=an.rundate.strftime('%Y-%m-%d %H:%M:%S')),
MeasurementValue(name='Irradiation',
value=self._get_irradiation(an)),
MeasurementValue(name='J', value=jf),
MeasurementValue(name='Lambda K',
value=nominal_value(ar.arar_constants.lambda_k)),
MeasurementValue(name='Project', value=an.project),
MeasurementValue(name='Sample', value=an.sample),
MeasurementValue(name='Material', value=an.material),
MeasurementValue(name='Comment', value=an.comment),
MeasurementValue(name='Ar39Decay', value=floatfmt(a39)),
MeasurementValue(name='Ar37Decay', value=floatfmt(a37)),
MeasurementValue(name='Sens.', value=floatfmt(an.sensitivity))
]
self.measurement_values = ms
def assemble_lines(self):
reg = self.component.regressor
v, e = reg.predict(0), reg.predict_error(0)
lines = [
reg.make_equation(),
'x=0, y={} +/-{}({}%)'.format(floatfmt(v, n=9), floatfmt(e, n=9),
format_percent_error(v, e))
]
if not reg.mswd in ('NaN', None):
valid = '' if reg.valid_mswd else '*'
lines.append('MSWD= {}{}, n={}'.format(valid,
floatfmt(reg.mswd, n=3),
reg.n))
lines.extend(
map(unicode.strip, map(unicode,
reg.tostring().split(','))))
return lines
def _load_air_computed(self, an, new_list):
if new_list:
c = an.arar_constants
ratios = [('40Ar/36Ar', 'Ar40/Ar36', nominal_value(c.atm4036)),
('40Ar/38Ar', 'Ar40/Ar38', nominal_value(c.atm4038))]
cv = self._make_ratios(ratios)
self.computed_values = cv
self._update_ratios()
try:
niso, diso = self._get_ratio('Ar40/Ar36')
if niso and diso:
noncorrected = self._get_non_corrected_ratio(niso, diso)
v, e = nominal_value(noncorrected), std_dev(noncorrected)
ref = 295.5
self.summary_str = u'Ar40/Ar36={} {}{}({}%) IC={:0.5f}'.format(floatfmt(v),
PLUSMINUS, floatfmt(e),
format_percent_error(v, e),
nominal_value(noncorrected / ref))
except:
pass
def _get_baseline_percent_error_text(self, *args):
b = self.item.baseline
return format_percent_error(b.value, b.error)
def _get_blank_percent_error_text(self, *args):
b = self.item.blank
return format_percent_error(b.value, b.error)
def _get_age_string(self):
a = self.age
e = self.age_err
pe = format_percent_error(a, e)
return u'{} +/-{} ({}%)'.format(floatfmt(a), floatfmt(e), pe)
def _get_interference_corrected_percent_error_text(self):
v = self.item.get_interference_corrected_value()
return format_percent_error(v.nominal_value, v.std_dev)
def _get_baseline_percent_error_text(self):
b = self.item.baseline
return format_percent_error(b.value, b.error)
def _get_value_percent_error_text(self):
cv = self.item.get_non_detector_corrected_value()
return format_percent_error(cv.nominal_value, cv.std_dev)
def age_string(self):
a = self.age
e = self.age_err
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def _get_intercept_percent_error_text(self):
v = self.item.uvalue
return format_percent_error(nominal_value(v), std_dev(v))
def value_string(self, t):
a, e = self._value_string(t)
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def _get_ic_decay_corrected_percent_error_text(self):
v = self.item.get_ic_decay_corrected_value()
return format_percent_error(nominal_value(v), std_dev(v))
def _add_results_info(self, plot, label=None, text_color='black'):
ag = self.analysis_group
age = ag.isochron_age
a = ag.isochron_3640
n = ag.nanalyses
mswd = ag.isochron_regressor.mswd
intercept, err = nominal_value(a), std_dev(a)
try:
inv_intercept = intercept ** -1
p = calc_percent_error(intercept, err, scale=1)
err = inv_intercept * p * self.options.nsigma
mse = err * mswd ** 0.5
sf = self.options.yintercept_sig_figs
v, e, p, mse = floatfmt(inv_intercept, n=sf, s=3), floatfmt(err, n=sf, s=3), \
floatfmt(p * 100, n=2), floatfmt(mse, s=3)
except ZeroDivisionError:
v, e, p, mse = 'NaN', 'NaN', 'NaN', 'NaN'
sample_line = u'{}({})'.format(ag.identifier, ag.sample)
mse_text = ''
if self.options.include_4036_mse:
mse_text = ' MSE= {}'.format(mse)
ptext = ''
if self.options.include_percent_error:
ptext = ' ({}%)'.format(p)
ratio_line = '<sup>40</sup>Ar/<sup>36</sup>Ar= {} {}{}{}{}'.format(v, PLUSMINUS, e, ptext, mse_text)
v = nominal_value(age)
e = std_dev(age) * self.options.nsigma
p = format_percent_error(v, e)
mse_age = e * mswd ** 0.5
valid = validate_mswd(mswd, n)
mswd = '{:0.2f}'.format(mswd)
if not valid:
mswd = '*{}'.format(mswd)
af = self.options.age_sig_figs
mse_text = ''
if self.options.include_age_mse:
mse_text = ' MSE= {}'.format(floatfmt(mse_age, s=3))
age_line = u'Age= {} {}{} ({}%) {}{}'.format(floatfmt(v, n=af),
PLUSMINUS,
floatfmt(e, n=af, s=3), p, ag.age_units, mse_text)
mswd_line = 'N= {} MSWD= {}'.format(n, mswd)
if label is None:
th = 0
for overlay in plot.overlays:
if isinstance(overlay, OffsetPlotLabel):
w, h = overlay.get_preferred_size()
th += h + self.options.results_info_spacing
label = OffsetPlotLabel(
offset=(1, th),
component=plot,
overlay_position='inside bottom',
hjustify='left',
bgcolor='white',
font=self.options.results_font,
color=text_color)
plot.overlays.append(label)
self._plot_label = label
lines = u'\n'.join((sample_line, ratio_line, age_line, mswd_line))
label.text = u'{}'.format(lines)
label.bgcolor = plot.bgcolor
label.request_redraw()
def age_string(self):
a = self.age
e = self.age_err
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def value_string(self, t):
a, e = self._value_string(t)
pe = format_percent_error(a, e)
return u'{} {}{} ({}%)'.format(floatfmt(a), PLUSMINUS, floatfmt(e), pe)
def _get_value_percent_error_text(self, *args):
cv = self.item.get_non_detector_corrected_value()
return format_percent_error(cv.nominal_value, cv.std_dev)
def _get_percent_error_text(self):
return format_percent_error(self.item.value, self.item.error)
def _get_percent_error_text(self):
e = self.item.error
v = self.item.value
return format_percent_error(v, e)
def _get_percent_error_text(self):
e = self.item.error
v = self.item.value
return format_percent_error(v, e)
def _get_interference_corrected_percent_error_text(self):
v = self.item.get_interference_corrected_value()
return format_percent_error(v.nominal_value, v.std_dev)
def _get_intercept_percent_error_text(self):
v = self.item.uvalue
return format_percent_error(nominal_value(v), std_dev(v))
def _get_blank_percent_error_text(self):
b = self.item.blank
return format_percent_error(b.value, b.error)
def _get_bs_bk_corrected_percent_error_text(self):
v = self.item.get_non_detector_corrected_value()
return format_percent_error(v.nominal_value, v.std_dev)
def func(ai):
uv = ai.get_value(i_attr)
v = nominal_value(uv)
e = std_dev(uv)
pe = format_percent_error(v, e)
return '{}= {}+/-{}({}%)'.format(fi_attr, floatfmt(v), floatfmt(e), pe)
def _add_results_info(self, plot, label=None, text_color='black'):
ag = self.analysis_group
age = ag.isochron_age
a = ag.isochron_4036
n = ag.nanalyses
mswd = ag.isochron_regressor.mswd
intercept, err = nominal_value(a), std_dev(a)
try:
inv_intercept = intercept ** -1
p = calc_percent_error(intercept, err, scale=1)
err = inv_intercept * p * self.options.nsigma
mse = err * mswd ** 0.5
v, e, p, mse = floatfmt(inv_intercept, s=3), floatfmt(err, s=3), floatfmt(p * 100, n=2), floatfmt(mse, s=3)
except ZeroDivisionError:
v, e, p, mse = 'NaN', 'NaN', 'NaN', 'NaN'
sample_line = u'{}({})'.format(ag.identifier, ag.sample)
ratio_line = u'Ar40/Ar36= {} {}{} ({}%) mse= {}'.format(v, PLUSMINUS, e, p, mse)
v = nominal_value(age)
e = std_dev(age) * self.options.nsigma
p = format_percent_error(v, e)
mse_age = e * mswd ** 0.5
valid = validate_mswd(mswd, n)
mswd = '{:0.2f}'.format(mswd)
if not valid:
mswd = '*{}'.format(mswd)
age_line = u'Age= {} {}{} ({}%) {}. mse= {}'.format(floatfmt(v, n=3),
PLUSMINUS,
floatfmt(e, n=4, s=3), p, ag.age_units,
floatfmt(mse_age, s=3))
mswd_line = 'N= {} mswd= {}'.format(n, mswd)
if label is None:
th = 0
for overlay in plot.overlays:
if isinstance(overlay, OffsetPlotLabel):
w, h = overlay.get_preferred_size()
th += h + self.options.results_info_spacing
label = OffsetPlotLabel(
offset=(1, th),
component=plot,
overlay_position='inside bottom',
hjustify='left',
bgcolor='white',
font=self.options.results_font,
color=text_color)
plot.overlays.append(label)
self._plot_label = label
lines = u'\n'.join((sample_line, ratio_line, age_line, mswd_line))
label.text = u'{}'.format(lines)
label.bgcolor = plot.bgcolor
label.request_redraw()
def _get_percent_error_text(self):
return format_percent_error(self.item.value, self.item.error)
def _get_age_string(self):
a = self.age
e = self.age_err
pe = format_percent_error(a, e)
return u'{} +/-{} ({}%)'.format(floatfmt(a), floatfmt(e), pe)
