ararpy 0.1.35__py3-none-any.whl → 0.1.37__py3-none-any.whl

ararpy/__init__.py

@@ -16,10 +16,10 @@ from . import calc, smp, files, thermo, test
 """ Information """
 
 name = 'ararpy'
-version = '0.1.35'
+version = '0.1.37'
 __version__ = version
 full_version = version
-last_update = '2025-12-02'
+last_update = '2025-12-12'
 
 """ ArArPy Functions """
 
@@ -141,6 +141,5 @@ RawData.get_sequence = smp.raw.get_sequence
 RawData.to_sample = smp.initial.from_raw_data
 RawData.get_unknown = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_unknown', unique=False)
 RawData.get_blank = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_blank', unique=False)
-RawData.get_air = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_air', unique=False)
 Sequence.get_data_df = lambda _seq: pd.DataFrame(_seq.data)
 Sequence.get_flag_df = lambda _seq: pd.DataFrame(_seq.flag)

ararpy/calc/basic.py

@@ -57,6 +57,18 @@ def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int,
     return ts - base
 
 
+def get_timestring(timestamp: int = 0, base=None):
+    """
+    :param timestamp: timestamp (utz)
+    :param base: base time [y, m, d, h, m]
+    :return:
+    """
+    if base is None:
+        base = [1970, 1, 1, 0, 0]
+    ts = timestamp + datetime(*base, tzinfo=timezone.utc).timestamp()
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(timespec='seconds')
+
+
 def merge_dicts(a: dict, b: dict):
     """
     a and b, two dictionary. Return updated a

ararpy/calc/raw_funcs.py

@@ -30,8 +30,8 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
 
     """
     def power(a0, a1):
-        return regression.power(a0, a1)
-        # raise ValueError("Deprecated regression")
+        # return regression.power(a0, a1)
+        raise ValueError("Deprecated regression")
     # if unselected is None:
     #     unselected = []
     # linesData = []
@@ -42,9 +42,9 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
         power, regression.average]
     # size = 50
     # lines_x = [(max(x + un_x) - 0) / size * i for i in range(size + 1)]
+    x, y = transpose(points_data, ignore=False)
     for i in range(len(reg_handler)):
         try:
-            x, y = transpose(points_data, ignore=False)
             res = reg_handler[i](a0=y, a1=x)
             # line_data = transpose([lines_x, res[7](lines_x)])
             line_results = res[0:4]

ararpy/calc/regression.py

@@ -16,7 +16,7 @@ import traceback
 import numpy as np
 import pandas as pd
 from scipy.stats import distributions
-from scipy.optimize import fsolve
+from scipy.optimize import minimize_scalar
 import warnings
 from scipy.optimize import minimize
 warnings.simplefilter(action="ignore", category=RuntimeWarning)
@@ -495,22 +495,25 @@ def linest(a0: list, a1: list, *args):
     # calculate Y values base on the fitted formula
     estimate_y = np.matmul(x, beta)
     resid = (estimate_y - y) ** 2
-    reg = (estimate_y - np.mean(estimate_y)) ** 2
-    ssresid = resid.sum()
-    ssreg = reg.sum()
-    sstotal = ssreg + ssresid
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
+    r2 = ssreg / sstotal if sstotal != 0 else np.inf
+
     df = m - n
-    m_ssresid = ssresid / df
-    se_beta = (m_ssresid * np.diagonal(inv_xtx)) ** .5
-    beta = beta.transpose()[0]
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
+    se_beta = np.diagonal(cov_beta) ** .5
+
+    beta = beta.flatten()
     rse_beta = se_beta / beta
-    r2 = ssreg / sstotal if sstotal != 0 else np.inf
 
     def get_adjusted_y(*args):
         args = [[1] * len(args[0]), *args]
         return [sum([beta[i] * args[i][j] for i in range(len(beta))]) for j in range(len(args[0]))]
 
-    return beta[0], se_beta[0], rse_beta[0] * 100, r2, m_ssresid, beta, se_beta, get_adjusted_y, m_ssresid
+    return beta[0], se_beta[0], abs(rse_beta[0]) * 100, r2, m_ssresid, beta, cov_beta, get_adjusted_y, m_ssresid
 
 
 def average(a0: list, a1=None):
@@ -535,12 +538,12 @@ def average(a0: list, a1=None):
     m_ssresid = ssresid / df
     r2 = ssreg / sstotal if sstotal != 0 else 1  # r2 = ssreg / sstotal
 
-    k1 = pow(sum([(i - k0) ** 2 for i in a0]) / df, 0.5)  # standard deviation
-    k2 = k1 / k0 * 100 if k0 != 0 else 0  # relative standard error
+    k6 = [[sum([(i - k0) ** 2 for i in a0]) / df]]
+    k1 = pow(k6[0][0], 0.5)  # standard deviation
+    k2 = k1 / abs(k0) * 100 if k0 != 0 else 0  # relative standard error
     k3 = r2  # determination coefficient
-    k4 = 'MSWD'
+    k4 = m_ssresid  # 'MSWD'
     k5 = [k0]
-    k6 = [k1]
     k8 = m_ssresid
 
     def get_adjusted_y(x: list):
@@ -737,7 +740,7 @@ def quadratic(a0: list, a1: list):
     """
     # y = b + m1 * x + m2 * x ^ 2
     k = list(linest(a0, a1, [i ** 2 for i in a1]))
-    b, seb, rseb, r2, mswd, [b, m1, m2], [seb, sem1, sem2] = k[0:7]
+    [b, m1, m2] = k[5]
 
     def get_adjusted_y(x: list):
         return [b + m1 * _x + m2 * _x ** 2 for _x in x]
@@ -756,7 +759,7 @@ def polynomial(a0: list, a1: list, degree: int = 5):
     """
     # y = b + m1 * x + m2 * x ^ 2 + ... + m[n] * x ^ n
     k = list(linest(a0, *[[j ** (i + 1) for j in a1] for i in range(degree)]))
-    b, seb, rseb, r2, mswd, beta, se_beta = k[0:7]
+    beta = k[5]
 
     def get_adjusted_y(x: list):
         return [sum([beta[i] * _x ** i for i in range(degree + 1)]) for _x in x]
@@ -766,6 +769,7 @@ def polynomial(a0: list, a1: list, degree: int = 5):
     return k
 
 
+### Deprecated
 def logest(a0: list, a1: list):
     """
     :param a0: known_y's, y = b * m ^ x
@@ -775,15 +779,19 @@ def logest(a0: list, a1: list):
     # y = b * m ^ x, Microsoft Excel LOGEST function, ln(y) = ln(b) + ln(m) * x
     a0 = [np.log(i) for i in a0]  # ln(y)
     linest_res = linest(a0, a1)
-    lnb, selnb, rseb, r2, mswd, [lnb, lnm], [selnb, selnm] = linest_res[0:7]
+    lnb, selnb, rseb, r2, mswd, beta, cov_beta = linest_res[0:7]
+    lnb, lnm = beta
+    selnb, selnm = np.diagonal(cov_beta) ** .5
+
     b = np.exp(lnb)
     m = np.exp(lnm)
     sem = np.exp(lnm) * selnm
     seb = np.exp(lnb) * selnb  # Excel.Logest function do not consider the error propagation
-    rseb = seb / b * 100
+    rseb = seb / abs(b) * 100
     return b, seb, rseb, r2, mswd, m, sem
 
 
+### Deprecated
 def power(a0: list, a1: list):
     """
     :param a0: known_y's, y = a * x ^ b + c
@@ -841,7 +849,9 @@ def power(a0: list, a1: list):
         raise IndexError
 
     f = linest(a0, [_x ** b for _x in a1])
-    a, sea, c, sec = f[5][1], f[6][1], f[0], f[1]
+    beta, cov_beta = f[5:7]
+    c, a = beta
+    sec, sea = np.diagonal(cov_beta) ** .5
 
     calculated_y = [_pow_func(i, a, b, c) for i in a1]
     resid = [(calculated_y[i] - a0[i]) ** 2 for i in range(len(a0))]
@@ -862,104 +872,193 @@ def power(a0: list, a1: list):
     errfx = pow(sum([i ** 2 for i in a1]) / (dp * sum([i ** 2 for i in a1]) - sum(a1) ** 2), 0.5)
     # seb = errfz * sey = errfz * ssresid / df -> se_intercept = sey * errfx = seb / errfz * errfx
     se_intercept = sec / errfz * errfx
-    rse_intercept = se_intercept / intercept * 100
+    rse_intercept = se_intercept / abs(intercept) * 100
+
+
+    exp_beta = [a, b, c]
+    exp_cov_beta = [
+        [cov_beta[1][1], 0, cov_beta[1][0]],
+        [0,              0,              0],
+        [cov_beta[0][1], 0, cov_beta[0][0]],
+    ]
 
     return intercept, se_intercept, rse_intercept, r2, 'mswd', [a, b, c], 'se', \
            lambda x: [_pow_func(i, a, b, c) for i in x], m_ssresid
 
 
 def exponential(a0: list, a1: list):
-    """
-    :param a0: known_y's, y = a * b ^ x + c
-    :param a1: known_x's
-    :return: intercept | standard error of intercept | relative error | R2 | MSWD | [m, c, b] | [sem, sec, seb]
-    """
+    try:
+        k = _exponential(a0, a1, newton_minimize_1d)
+        if k[2] > 100:
+            raise ValueError
+        if abs(k[0] - min(a0)) > 5 * (max(a0) - min(a0)):
+            raise ValueError
+    except Exception as e:
+        print(f"newton_minimize_1d failed, using grad minimize")
+        k = _exponential(a0, a1, grad_minimize)
+    return k
 
-    def _exp_func(x, a, b, c):
-        return a * b ** x + c
 
-    def _residuals(params):
-        a, b, c = params
-        return [_exp_func(xi, a, b, c) - yi for xi, yi in zip(a1, a0)]
+def _exponential(a0, a1, method):
 
-    def _sum_squared_error(params):
-        return sum(r**2 for r in _residuals(params))
+    X = np.array(a1)
+    Y = np.array(a0)
+    y = np.array([a0]).transpose()
 
-    def _get_ac(b):
-        f = linest(a0, [b ** xi for xi in a1])
-        return f[5][1], b, f[0]
+    def _exp_func(xi, a, b, c):
+        return a * np.exp(b * xi) + c
+
+    @np.vectorize
+    def _get_s(b):
+        x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+        try:
+            inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+        except np.linalg.LinAlgError:
+            raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+        beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+        c, a = beta.flatten()
+        reg_y = _exp_func(X, a, b, c)
+        resid = (reg_y - Y) ** 2
+        ssresid = sum(resid)
+        return ssresid
+
+    # 1阶
+    ini_f1 = linest(Y, X)
+    y_range = max(Y) - min(Y)
+    ini_b = ini_f1[5][1] / max(y_range, 1e-12)
+    # 2阶
+    ini_f2 = quadratic(Y, X)
+    ini_b *= np.sign(ini_f1[5][1]) * np.sign(ini_f2[5][2])
+
+    b, count = method(_get_s, ini_b)
+
+    x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+
+    m, n = x.shape  # number of data, number of unknown x
+    try:
+        inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+    except np.linalg.LinAlgError:
+        raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+    beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+    estimate_y = np.matmul(x, beta)
+    resid = (estimate_y - y) ** 2
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
+    r2 = ssreg / sstotal if sstotal != 0 else 1
 
-    def _get_init():
-        f = linest(np.log(np.array(a0)), np.array(a1))
-        return np.exp(f[0]), np.exp(f[5][1]), 0
+    df = m - n
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
 
-    try:
-        a, b, c = _get_init()
-        # a, b, c = minimize(_sum_squared_error, [a, b, c], method="Nelder-Mead").x  # 优化方法
-        count = 0
-        step = 0.01
-        while count < 100:
-            a, b, c = _get_ac(b)
-            s = _sum_squared_error([a, b, c])
-            b_left, b_right = b - step * b, b + step * b
-            s_left = _sum_squared_error(_get_ac(b_left))
-            s_right = _sum_squared_error(_get_ac(b_right))
-            if s_left > s > s_right:
-                b = b_right
-                continue
-            elif s_left < s < s_right:
-                b = b_left
-                continue
-            elif s_left < s_right:
-                b = (b + b_left) / 2
-            else:
-                b = (b + b_right) / 2
-            count += 1
-            step = step * 0.5
-            if step < 0.000001:
-                break
+    sc, sa = np.diagonal(cov_beta) ** .5
+    c, a = beta.flatten()
+    intercept = a + c
+    se_intercept = pow(sa ** 2 + sc ** 2 + 2 * cov_beta[0][1] , 0.5)
 
-    except RuntimeError:
-        raise RuntimeError
-    except np.linalg.LinAlgError:
-        raise np.linalg.LinAlgError
-    except TypeError:
-        raise TypeError
-    except IndexError:
-        raise IndexError
+    exp_beta = [a, b, c]
+    exp_cov_beta = [
+        [cov_beta[1][1], 0, cov_beta[1][0]],
+        [0,              0,              0],
+        [cov_beta[0][1], 0, cov_beta[0][0]],
+    ]
 
-    f = linest(a0, [b ** xi for xi in a1])
-    a, sea, c, sec = f[5][1], f[6][1], f[0], f[1]
+    # print(f"{b = }, {a = }, {c = }, {count = }, {ssresid = }, {r2 = }")
 
-    calculated_y = [_exp_func(i, a, b, c) for i in a1]
-    resid = [(calculated_y[i] - a0[i]) ** 2 for i in range(len(a0))]
-    reg = [(i - sum(calculated_y) / len(calculated_y)) ** 2 for i in calculated_y]
-    ssresid = sum(resid)
-    ssreg = sum(reg)
-    sstotal = ssreg + ssresid
-    dp = len(a1)
-    df = dp - 1
-    m_ssresid = ssresid / df
-    r2 = ssreg / sstotal if sstotal != 0 else 1
+    return intercept, se_intercept, se_intercept / abs(intercept) * 100, r2, m_ssresid, exp_beta, exp_cov_beta, \
+           lambda x: [_exp_func(xi, a, b, c) for xi in x], m_ssresid
 
-    z = [b ** xi for xi in a1]
-    intercept = a + c
-    se_intercept_1 = np.sqrt(sea ** 2 + sec ** 2)
-    # calculate error of intercept
-    errfz = pow(sum([i ** 2 for i in z]) / (dp * sum([i ** 2 for i in z]) - sum(z) ** 2), 0.5)
-    errfx = pow(sum([i ** 2 for i in a1]) / (dp * sum([i ** 2 for i in a1]) - sum(a1) ** 2), 0.5)
-    # seb = errfz * sey = errfz * ssresid / df -> se_intercept = sey * errfx = seb / errfz * errfx
-    se_intercept = sec / errfz * errfx
-    rse_intercept = se_intercept / intercept * 100
 
-    return intercept, se_intercept, rse_intercept, r2, 'mswd', [a, b, c], 'se', \
-           lambda x: [_exp_func(i, a, b, c) for i in x], m_ssresid
+def newton_minimize_1d(func, x0, h=1e-5, tol=1e-8, max_iter=30):
+    x = x0
+    for i in range(max_iter):
+        fx = func(x)
+        if not np.isfinite(fx):
+            raise ValueError("Newton Minimize: Function returned non-finite value at x={}".format(x))
+
+        # 一阶导数（中心差分）
+        f_plus = func(x + h)
+        f_minus = func(x - h)
+        if not (np.isfinite(f_plus) and np.isfinite(f_minus)):
+            raise ValueError("Newton Minimize: Non-finite values in derivative computation")
+        df = (f_plus - f_minus) / (2 * h)
+        d2f = (f_plus - 2 * fx + f_minus) / (h * h)
+
+        # 牛顿步长
+        if abs(d2f) < 1e-12:  # 避免除零或平坦区域
+            raise ValueError("Newton Minimize: Second derivative too small, stopping.")
+
+        step = df / d2f
+        x_new = x - step
+
+        if abs(step) < tol:
+            x = x_new
+            break
+
+        x = x_new
+
+    if i + 1 == max_iter:
+        raise ValueError("Newton Minimize: Over iteration max_iter={}".format(max_iter))
+
+    return x, i + 1
+
+
+def grad_minimize(func, x, lr=1e-5, tol=1e-8, max_iter=1000):
+
+    for i in range(max_iter):
+        f_plus = func(x + lr)
+        f_minus = func(x - lr)
+        if not (np.isfinite(f_plus) and np.isfinite(f_minus)):
+            raise ValueError("Newton Minimize: Non-finite values in derivative computation")
+        g = (f_plus - f_minus) / (2 * lr)
+        x_new = x - lr * g
+        if abs(func(x_new) - func(x)) < tol:
+            break
+        x = x_new
+    return x, i+1
 
 
 """ line functions """
 
 
-def linear_eq(x: list, beta: list):
+def linest_var(beta: list, cov: list, x: float):
+    """ y = b0 * x^0 + b1 * x^1 + ... + bn * x^n
+    Parameters
+    ----------
+
+    Returns
+    -------
+
+    """
+    beta = np.array(beta, dtype=np.float64)
+    cov_matrix = np.array(cov, dtype=np.float64)
+    g = np.array([x ** k for k in range(len(beta))]).reshape(-1, 1)
+    y = np.dot(g.T, beta.reshape(-1, 1))[0, 0]
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
+
+
+def quadratic_var(beta: list, cov: list, x: float):
+    """ y = b0 * x^0 + b1 * x^1 + b2 * x^2
+    Parameters
+    ----------
+    beta : coefficients
+    x :
+
+    Returns
+    -------
+
+    """
+    beta = np.array(beta, dtype=np.float64)
+    cov_matrix = np.array(cov, dtype=np.float64)
+    g = np.array([x ** k for k in range(len(beta))]).reshape(-1, 1)
+    y = np.dot(g.T, beta.reshape(-1, 1))[0, 0]
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
+
+
+def average_var(beta: list, cov: list, x: float):
     """ y = b0 * x^0 + b1 * x^1 + ... + bn * x^n
     Parameters
     ----------
@@ -970,21 +1069,29 @@ def linear_eq(x: list, beta: list):
     -------
 
     """
-    return [np.prod([beta, [_x ** i for i in range(len(beta))]], axis=0).sum() for _x in x]
+    y, = beta
+    var = np.array(cov, dtype=np.float64)[0, 0]
+    return y, var
 
 
-def exponential_eq(x: list, beta: list):
-    """ y = a * b ^ x + c
+def exponential_var(beta: list, cov: list, x: float):
+    """ y = a * exp(bx) + c
     Parameters
     ----------
     beta : coefficients, [a, b, c]
-    x :
+    cov : covariance [[], [], []]
 
     Returns
     -------
 
     """
-    return [beta[0] * beta[1] ** _x + beta[0] for _x in x]
+    cov_matrix = np.array(cov)
+    a, b, c = beta
+    k = np.exp(b*x)
+    g = np.array([k, a*x*k, 1]).reshape(-1, 1)
+    y = a * k + c
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
 
 
 def power_eq(x: list, beta: list):

ararpy/files/calc_file.py

@@ -493,40 +493,41 @@ def open_full_xls(file_path: str, sample_name: str = ''):
         res['Inverse Isochron Table'], rows, [4, 5, 6, 7, 10])
     total_param = arr.partial(
         res['Sample Parameters'], rows, [
-            # 1, 2,  # 0-1
-            -1, -1, -1, -1,  # 2-5
-            -1, -1, -1, -1,  # 6-9
-            -1, -1, -1, -1, -1, -1,  # 10-15
-            -1, -1, -1, -1,  # 16-19
-            -1, -1,  # 20-21
-            23, 24, -1, -1, -1, -1,  # 22-27
-            -1, -1,  # 28-29
-            22, -1, -1, -1,  # 30-33
-            -1, -1,  # 34-35
-            -1, -1,  # 36-37
-            -1, -1,  # 38-39
-            -1, -1,  # 40-41
-            -1, -1,  # 42-43
-            -1, -1,  # 44-45
-            -1, -1,  # 46-47
-            -1, -1,  # 48-49
-            -1, -1,  # 50-51
-            -1, -1,  # 52-53
-            -1, -1,  # 54-55
-            -1, -1,  # 56-57
-            -1, -1,  # 58-59
-            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 60-68
-            10, 11, 12, 13,  # 69-72
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 73-84
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 85-94
-            -1, -1, -1, -1,  # 95-98
-            -1, -1, -1, -1,  # 99-102
-            -1, -1, -1, -1,  # 103-106
-            -1, -1, -1, -1,  # 107-110
-            -1, -1, -1, -1,  # 111-114
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 115-122
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 123-130
-            -1, -1, -1, -1, -1,  # 131-135
+            # 1, 2, -1, # 0-2
+            -1, -1, -1, -1,  # 3-6
+            -1, -1, -1, -1,  # 7-10
+            -1, -1, -1, -1, -1, -1,  # 11-16
+            -1, -1, -1, -1,  # 17-20
+            -1, -1,  # 21-22
+            23, 24, -1, -1, -1, -1,  # 23-28
+            -1, -1,  # 29-30
+            22, -1, -1, -1,  # 31-34
+            -1, -1,  # 35-36
+            -1, -1,  # 37-38
+            -1, -1,  # 39-40
+            -1, -1,  # 41-42
+            -1, -1,  # 43-44
+            -1, -1,  # 45-46
+            -1, -1,  # 47-48
+            -1, -1,  # 49-50
+            -1, -1,  # 51-52
+            -1, -1,  # 53-54
+            -1, -1,  # 55-56
+            -1, -1,  # 57-58
+            -1, -1,  # 59-60
+            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 61-69
+            10, 11, 12, 13,  # 70-73
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 74-85
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 86-95
+            -1, -1, -1, -1,  # 96-99
+            -1, -1, -1, -1,  # 100-103
+            -1, -1, -1, -1,  # 104-107
+            -1, -1, -1, -1,  # 108-111
+            -1, -1, -1, -1,  # 112-115
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 116-123
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 124-131
+            -1, -1, -1, -1, -1,  # 132-136
+            -1, -1, -1, -1,  # 137-140
         ])
 
     month_convert = {'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',

ararpy/files/raw_file.py

@@ -94,62 +94,13 @@ def open_file(file_path: str, input_filter: List[Union[str, int, bool]], name=No
     """
     extension = str(os.path.split(file_path)[-1]).split('.')[-1]
     try:
-        handler = {'txt': open_raw_txt, 'excel': open_raw_xls,
-                   'Qtegra Exported XLS': open_qtegra_exported_xls, 'Seq': open_raw_seq}[
-            ['txt', 'excel', 'Qtegra Exported XLS', 'Seq'][int(input_filter[1])]]
+        handler = {'txt': open_raw_txt, 'excel': open_raw_xls, 'Seq': open_raw_seq}[
+            ['txt', 'excel', 'Qtegra Excel (deleted)', 'Seq'][int(input_filter[1])]]
     except KeyError:
         raise FileNotFoundError("Wrong File.")
     return handler(file_path, input_filter, name)
 
 
-def open_qtegra_exported_xls(filepath, input_filter=None, name=None):
-    if input_filter is None:
-        input_filter = []
-    try:
-        wb = open_workbook(filepath)
-        sheets = wb.sheet_names()
-        sheet = wb.sheet_by_name(sheets[0])
-        value, step_header, step_list = [], [], []
-        for row in range(sheet.nrows):
-            row_set = []
-            for col in range(sheet.ncols):
-                if sheet.cell(row, col).value == '':
-                    pass
-                else:
-                    row_set.append(sheet.cell(row, col).value)
-            if row_set != [] and len(row_set) > 1:
-                value.append(row_set)
-        for each_row in value:
-            # if the first item of each row is float (1.0, 2.0, ...) this row is the header of a step.
-            if isinstance(each_row[0], float):
-                each_row[0] = int(each_row[0])
-                if "M" in each_row[1].upper():
-                    each_row[1] = datetime.strptime(each_row[1], '%m/%d/%Y  %I:%M:%S %p').isoformat(timespec='seconds')
-                else:
-                    each_row[1] = datetime.strptime(each_row[1], '%m/%d/%Y  %H:%M:%S').isoformat(timespec='seconds')
-                step_header.append(each_row)
-        for step_index, each_step_header in enumerate(step_header):
-            row_start_number = value.index(each_step_header)
-            try:
-                row_stop_number = value.index(step_header[step_index + 1])
-            except IndexError:
-                row_stop_number = len(value) + 1
-            step_values = [
-                each_step_header[0:4],
-                *list(map(
-                    # lambda x: [x[0], x[1], x[2], x[1], x[3], x[1], x[4], x[1], x[5], x[1], x[6]],
-                    # x[1] = time, x[2] = H2:40, x[3] = H1: 39, x[4] = AX: 38, x[5] = L1: 37, x[6] = L2: 36
-                    lambda x: [x[0], x[1], x[6], x[1], x[5], x[1], x[4], x[1], x[3], x[1], x[2]],
-                    # in sequence: Ar36, Ar37, Ar38, Ar39, Ar40
-                    [value[i] for i in range(row_start_number + 2, row_stop_number - 7, 1)]))
-            ]
-            step_list.append(step_values)
-    except Exception as e:
-        raise ValueError('Error in opening the original file: %s' % str(e))
-    else:
-        return {'data': step_list}
-
-
 def open_raw_txt(file_path, input_filter: List[Union[str, int]], name=None):
     """
     Parameters
@@ -257,20 +208,34 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
 
     """
 
-    def datetime_parse(string, f):
+    def datetime_parse(string: str, f: str):
         try:
             return datetime.strptime(string, f)
         except ValueError as v:
+            # print(traceback.format_exc())
             if f.strip() == "":
                 return datetime_parser.parse(string)
             elif len(v.args) > 0 and v.args[0].startswith('unconverted data remains: '):
-                string = string[:-(len(v.args[0]) - 26)]
-                return datetime.strptime(string, f)
+                # %f handles microseconds (6 digits), remove the remains
+                return datetime_parse(string[:-(len(v.args[0]) - 26)], f)
+            # elif f.upper()[-2:] in ['PM', 'AM']:
+            #     return datetime_parse(string, f[:-2])
             else:
                 raise
 
+    def step_num_parse(s: str):
+        try:
+            return f"{round(float(s)):02d}"
+        except (ValueError, TypeError):
+            return s
+
+    def step_type_parse(s: str):
+        if any([s.lower().__contains__(each) for each in ['blk', 'blank']]):
+            return "Blank"
+        return "Unknown"
+
     step_list = []
-    idx = step_index = 0
+    step_idx = 0  # step_index rows
 
     header = input_filter[5]
     isotope_index = input_filter[8:28]
@@ -282,7 +247,7 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
     while True:  # measurment steps sloop
 
         # ============ all text information ============
-        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
+        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - step_idx, 1])
 
         # ============ Step name ============
         try:
@@ -293,13 +258,10 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 if res is not None and "en" in res.named.keys():
                     experiment_name = res.named.get("en")
                 if res is not None and "sn" in res.named.keys():
-                    step_index = res.named.get("sn")
-                    if step_index.isnumeric():
-                        step_name = f"{experiment_name}-{int(step_index):02d}"
-                    else:
-                        step_name = f"{experiment_name}-{step_index}"
-            if step_name == "":
-                raise ValueError(f"Step name not found")
+                    step_name = res.named.get("sn")
+            if str(step_name) == "":
+                raise ValueError(f"Step name not found, break reading steps")
+            step_name = f"{experiment_name}-{step_num_parse(step_name)}"
         except (TypeError, ValueError, IndexError):
             # When parsing the step name fails, the end of the file has been reached
             # raise
@@ -312,7 +274,7 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
         # ============ Step information ============
         try:
             if check_box_index[2]:
-                string = get_item(file_contents, strings_index[1:4], default="", base=[1, 1 - idx, 1])
+                string = get_item(file_contents, strings_index[1:4], default="", base=[1, 1 - step_idx, 1])
                 res = string_parser(strings_index[4], string)
                 if res is not None:
                     options.update(dict(zip(DEFAULT_SAMPLE_INFO.keys(), [res.named.get(value, options.get(key)) for key, value in DEFAULT_SAMPLE_INFO.items()])))
@@ -347,6 +309,15 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
             print(traceback.format_exc())
             raise ValueError(f"Failed to parse zero datetime: {e}")
             # zero_datetime = datetime(1970, 1, 1, 0, 0, 0).isoformat(timespec='seconds')
+
+        # ============== Step Type =============
+        step_type = step_type_parse(options.get("StepType"))  # blank or unknown
+        options.update({'StepType': step_type})
+
+        # ============== Step Type =============
+        exp_type = options.get("ExpType")  # crushing, laser, heating, air
+        options.update({'ExpType': exp_type})
+
         current_step = [[step_name, zero_datetime, options]]
 
         # ============ isotope data ============
@@ -360,9 +331,11 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 break_num += 1
                 continue
             break_num = 0
-            if int(data_index[2]) == 0:  # == 0, vertical
-                start_row = data_index[24] * cycle_num + data_index[25] * cycle_num + header + idx
-                try:
+            try:
+                if int(data_index[2]) == 0:  # == 0, vertical
+                    start_row = data_index[24] * cycle_num + data_index[25] * cycle_num + header + step_idx
+                    if check_box_index[0] and start_row - step_idx - header >= data_index[28]:
+                        break
                     current_step.append([
                         str(cycle_num + 1),
                         # in sequence: Ar36, Ar37, Ar38, Ar39, Ar40
@@ -377,47 +350,40 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                         float(data_content[start_row + isotope_index[ 2] - base][isotope_index[ 3] - base]),
                         float(data_content[start_row + isotope_index[ 0] - base][isotope_index[ 1] - base]) * f,
                     ])
-                except (ValueError, IndexError):
-                    print(f"Cannot parse isotope data")
-                    print(traceback.format_exc())
-                    current_step.append([
-                        str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
-                    ])
-            elif int(data_index[2]) == 1:  # == 1, horizontal
-                start_row = data_index[1] + idx
-                col_inc = data_index[24] * cycle_num + data_index[25] * cycle_num - base
-                try:
+                elif int(data_index[2]) == 1:  # == 1, horizontal
+                    start_row = data_index[1] + step_idx
+                    col_inc = data_index[24] * cycle_num + data_index[25] * cycle_num
                     current_step.append([
                         str(cycle_num + 1),
                         # Ar36, Ar37, Ar38, Ar39, Ar40
-                        float(data_content[start_row][isotope_index[19] + col_inc]),
-                        float(data_content[start_row][isotope_index[17] + col_inc]) * f,
-                        float(data_content[start_row][isotope_index[15] + col_inc]),
-                        float(data_content[start_row][isotope_index[13] + col_inc]) * f,
-                        float(data_content[start_row][isotope_index[11] + col_inc]),
-                        float(data_content[start_row][isotope_index[ 9] + col_inc]) * f,
-                        float(data_content[start_row][isotope_index[ 7] + col_inc]),
-                        float(data_content[start_row][isotope_index[ 5] + col_inc]) * f,
-                        float(data_content[start_row][isotope_index[ 3] + col_inc]),
-                        float(data_content[start_row][isotope_index[ 1] + col_inc]) * f,
-                    ])
-                except (ValueError, IndexError):
-                    print(f"Cannot parse isotope data")
-                    print(traceback.format_exc())
-                    current_step.append([
-                        str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
+                        float(data_content[start_row][isotope_index[19] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[17] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[15] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[13] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[11] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 9] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[ 7] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 5] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[ 3] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 1] + col_inc - base]) * f,
                     ])
-            else:
-                raise ValueError(f"{data_index[2]} not in [0, 1]")
+                else:
+                    raise ValueError(f"{data_index[2]} not in [0, 1]")
+            except Exception as e:
+                print(f"Cannot parse isotope data")
+                # print(traceback.format_exc())
+                current_step.append([
+                    str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
+                ])
 
             cycle_num += 1
             if cycle_num >= data_index[3]:
                 break
 
         step_list.append(current_step)
-        idx = data_index[28] * len(step_list)
+        step_idx = data_index[28] * len(step_list)
         if not check_box_index[0] or len(step_list) >= 500:  # check_box_index[0]: multiple sequences
-            print(f"Multiple Sequence = {check_box_index[0]}, Step number = {len(step_list)}")
+            # print(f"Multiple Sequence = {check_box_index[0]}, Step number = {len(step_list)}")
             break
 
     if not step_list:
@@ -441,39 +407,39 @@ def get_sample_info(file_contents: list, index_list: list, default="", base: Uni
     """
     sample_info = DEFAULT_SAMPLE_INFO.copy()
     sample_info.update({
-        "ExpName": get_item(file_contents, index_list[0:3], default=default, base=base),
-        "StepName": get_item(file_contents, index_list[3:6], default=default, base=base),
-        "StepType": get_item(file_contents, index_list[6:9], default=default, base=base),
-        "StepLabel": get_item(file_contents, index_list[9:12], default=default, base=base),
-        "ZeroYear": get_item(file_contents, index_list[12:15], default=default, base=base),
-        "ZeroHour": get_item(file_contents, index_list[15:18], default=default, base=base),
-        "ZeroMon": get_item(file_contents, index_list[18:21], default=default, base=base),
-        "ZeroMin": get_item(file_contents, index_list[21:24], default=default, base=base),
-        "ZeroDay": get_item(file_contents, index_list[24:27], default=default, base=base),
-        "ZeroSec": get_item(file_contents, index_list[27:30], default=default, base=base),
-        "SmpName": get_item(file_contents, index_list[30:33], default=default, base=base),
-        "SmpLoc": get_item(file_contents, index_list[33:36], default=default, base=base),
-        "SmpMatr": get_item(file_contents, index_list[36:39], default=default, base=base),
-        "ExpType": get_item(file_contents, index_list[39:42], default=default, base=base),
-        "SmpWeight": get_item(file_contents, index_list[42:45], default=default, base=base),
-        "Stepunit": get_item(file_contents, index_list[45:48], default=default, base=base),
-        "HeatingTime": get_item(file_contents, index_list[48:51], default=default, base=base),
-        "InstrName": get_item(file_contents, index_list[51:54], default=default, base=base),
-        "Researcher": get_item(file_contents, index_list[54:57], default=default, base=base),
-        "Analyst": get_item(file_contents, index_list[57:60], default=default, base=base),
-        "Lab": get_item(file_contents, index_list[60:63], default=default, base=base),
-        "Jv": get_item(file_contents, index_list[63:66], default=default, base=base),
-        "Jsig": get_item(file_contents, index_list[66:69], default=default, base=base),
-        "MDF": get_item(file_contents, index_list[69:72], default=default, base=base),
-        "MDFSig": get_item(file_contents, index_list[72:75], default=default, base=base),
-        "CalcName": get_item(file_contents, index_list[75:78], default=default, base=base),
-        "IrraName": get_item(file_contents, index_list[78:81], default=default, base=base),
-        "IrraLabel": get_item(file_contents, index_list[81:84], default=default, base=base),
-        "IrraPosH": get_item(file_contents, index_list[84:87], default=default, base=base),
-        "IrraPosX": get_item(file_contents, index_list[87:90], default=default, base=base),
-        "IrraPosY": get_item(file_contents, index_list[90:93], default=default, base=base),
-        "StdName": get_item(file_contents, index_list[93:96], default=default, base=base),
-        "StdAge": get_item(file_contents, index_list[96:99], default=default, base=base),
-        "StdAgeSig": get_item(file_contents, index_list[99:102], default=default, base=base),
+        "ExpName": get_item(file_contents, index_list[0:3], default=default, base=base).strip(),
+        "StepName": get_item(file_contents, index_list[3:6], default=default, base=base).strip(),
+        "StepType": get_item(file_contents, index_list[6:9], default=default, base=base).strip(),
+        "StepLabel": get_item(file_contents, index_list[9:12], default=default, base=base).strip(),
+        "ZeroYear": get_item(file_contents, index_list[12:15], default=default, base=base).strip(),
+        "ZeroHour": get_item(file_contents, index_list[15:18], default=default, base=base).strip(),
+        "ZeroMon": get_item(file_contents, index_list[18:21], default=default, base=base).strip(),
+        "ZeroMin": get_item(file_contents, index_list[21:24], default=default, base=base).strip(),
+        "ZeroDay": get_item(file_contents, index_list[24:27], default=default, base=base).strip(),
+        "ZeroSec": get_item(file_contents, index_list[27:30], default=default, base=base).strip(),
+        "SmpName": get_item(file_contents, index_list[30:33], default=default, base=base).strip(),
+        "SmpLoc": get_item(file_contents, index_list[33:36], default=default, base=base).strip(),
+        "SmpMatr": get_item(file_contents, index_list[36:39], default=default, base=base).strip(),
+        "ExpType": get_item(file_contents, index_list[39:42], default=default, base=base).strip(),
+        "SmpWeight": get_item(file_contents, index_list[42:45], default=default, base=base).strip(),
+        "Stepunit": get_item(file_contents, index_list[45:48], default=default, base=base).strip(),
+        "HeatingTime": get_item(file_contents, index_list[48:51], default=default, base=base).strip(),
+        "InstrName": get_item(file_contents, index_list[51:54], default=default, base=base).strip(),
+        "Researcher": get_item(file_contents, index_list[54:57], default=default, base=base).strip(),
+        "Analyst": get_item(file_contents, index_list[57:60], default=default, base=base).strip(),
+        "Lab": get_item(file_contents, index_list[60:63], default=default, base=base).strip(),
+        "Jv": get_item(file_contents, index_list[63:66], default=default, base=base).strip(),
+        "Jsig": get_item(file_contents, index_list[66:69], default=default, base=base).strip(),
+        "MDF": get_item(file_contents, index_list[69:72], default=default, base=base).strip(),
+        "MDFSig": get_item(file_contents, index_list[72:75], default=default, base=base).strip(),
+        "CalcName": get_item(file_contents, index_list[75:78], default=default, base=base).strip(),
+        "IrraName": get_item(file_contents, index_list[78:81], default=default, base=base).strip(),
+        "IrraLabel": get_item(file_contents, index_list[81:84], default=default, base=base).strip(),
+        "IrraPosH": get_item(file_contents, index_list[84:87], default=default, base=base).strip(),
+        "IrraPosX": get_item(file_contents, index_list[87:90], default=default, base=base).strip(),
+        "IrraPosY": get_item(file_contents, index_list[90:93], default=default, base=base).strip(),
+        "StdName": get_item(file_contents, index_list[93:96], default=default, base=base).strip(),
+        "StdAge": get_item(file_contents, index_list[96:99], default=default, base=base).strip(),
+        "StdAgeSig": get_item(file_contents, index_list[99:102], default=default, base=base).strip(),
     })
     return sample_info

ararpy/smp/info.py

@@ -15,9 +15,9 @@
 
 def name(smp, n: str = None):
     if n is None:
-        return smp.Info.sample.name
+        return smp.Info.experiment.name
     elif isinstance(n, str):
-        smp.Info.sample.name = n
+        smp.Info.experiment.name = n
         return n
     else:
         raise ValueError(f"{n} is not a string")

ararpy/smp/initial.py

@@ -140,15 +140,18 @@ def initial(smp: Sample):
     # Info
     setattr(smp, 'Info', ArArBasic(
         id='0', name='info', attr_name='Info', arr_version=samples.VERSION,
+        experiment=ArArBasic(
+            name='', type='', instrument='', mass_spec='', collectors='', step_num=0,
+        ),
         sample=ArArBasic(
             name='SAMPLE NAME', material='MATERIAL', location='LOCATION', type='Unknown', method='',
-            sequence_unit='', weight=''
+            sequence_unit='', weight='',
         ),
         researcher=ArArBasic(
-            name='RESEARCHER', addr='ADDRESS', email='EMAIL'
+            name='RESEARCHER', addr='ADDRESS', email='EMAIL',
         ),
         laboratory=ArArBasic(
-            name='LABORATORY', addr='ADDRESS', email='EMAIL', info='INFORMATION', analyst='ANALYST'
+            name='LABORATORY', addr='ADDRESS', email='EMAIL', info='INFORMATION', analyst='ANALYST',
         ),
         results=ArArBasic(
             name='RESULTS', plateau_F=[], plateau_age=[], total_F=[], total_age=[],
@@ -184,9 +187,9 @@ def initial(smp: Sample):
             name='REFERENCE', journal='JOURNAL', doi='DOI'
         ),
         preference=copy.deepcopy(PREFERENCE_RES),
-        experiment=ArArBasic(
-            name='', mass_spec='', collectors='', step_num=0
-        ),
+        irradiation= ArArBasic(
+            label='', pos_h='', pos_x='', pos_y='',
+        )
     ))
 
     decimal_places = PREFERENCE_RES['decimalPlaces']
@@ -472,14 +475,14 @@ def from_raw_data(raw: RawData, mapping: Optional[List[dict]] = None) -> Sample:
     for row in mapping:
         row_unknown_intercept = []
         row_blank_intercept = []
-
         unknown: Sequence = raw.get_sequence(row['unknown'], flag='name')
-        if row['blank'].lower() == "Interpolated Blank".lower():
+        try:
+            blank: Sequence = raw.get_sequence(row['blank'], flag='name')
+            if blank is None or blank == []: raise KeyError
+        except KeyError:
             blank: Sequence = arr.filter(
-                raw.interpolated_blank, func=lambda seq: seq.datetime == unknown.datetime,
+                raw.interpolated_blank, func=lambda seq: seq.datetime == unknown.datetime and seq.name == row['blank'],
                 get=None, unique=True)
-        else:
-            blank: Sequence = raw.get_sequence(row['blank'], flag='name')
         for i in range(5):
             row_unknown_intercept = arr.multi_append(row_unknown_intercept, *unknown.results[i][int(unknown.fitting_method[i])][:2])
             row_blank_intercept = arr.multi_append(row_blank_intercept, *blank.results[i][int(blank.fitting_method[i])][:2])

ararpy/smp/json.py

@@ -50,8 +50,8 @@ class MyEncoder(json.JSONEncoder):
                             Plot.Set, Plot.BasicAttr, RawData, Sequence, ArArBasic)):
             if isinstance(obj, Sequence):
                 return dict(obj.__dict__, **{
-                    'is_blank': obj.is_blank(), 'is_unknown': obj.is_unknown(),
-                    'is_air': obj.is_air()})
+                    'is_blank': obj.is_blank(), 'is_unknown': obj.is_unknown()
+                })
             return obj.__dict__
         # Error
         if isinstance(obj, BaseException):

ararpy/smp/raw.py

@@ -52,8 +52,9 @@ def to_raw(file_path: Union[str, List[str]], input_filter_path: Union[str, List[
         data = res.get('data', None)
         sequences = res.get('sequences', None)
         sequence_num = len(data) if data is not None else len(sequences)
+        experiment_name = data[0][0][2]['ExpName'] if data is not None else file_name
         fitting_method = [2, 0, 2, 2, 2]  # 0 - linear, 1 - quadratic, 2 - exponential, 3 - power, 4 - average
-        raw = RawData(name=file_name, data=data, isotopic_num=10, sequence_num=sequence_num, source=[file_path],
+        raw = RawData(name=experiment_name, data=data, isotopic_num=10, sequence_num=sequence_num, source=[file_path],
                       sequence=sequences, unit=str(input_filter[30]), fitting_method=[*fitting_method])
     else:
         raise ValueError("File path and input filter should be both string or list with a same length.")
@@ -152,11 +153,10 @@ def do_regression(raw: RawData, sequence_index: Optional[List] = None, isotopic_
         # unselected: list = [unselected[[isotopic_index*2 + 1, 2 * (isotopic_index + 1)]].dropna().values.tolist()
         #                     for isotopic_index in list(range(5))]
 
-        for index, isotope in enumerate(selected):
+        for index, isotopic_data in enumerate(selected):
             if hasattr(isotopic_index, '__getitem__') and index not in isotopic_index:
                 continue
-            # print(f"regression for {sequence.name = }, isotope {index = }")
-            res = raw_funcs.get_raw_data_regression_results(isotope)
+            res = raw_funcs.get_raw_data_regression_results(isotopic_data)
             try:
                 sequence.results[index] = res[1]
                 sequence.coefficients[index] = res[2]

ararpy/smp/sample.py

@@ -109,67 +109,67 @@ ISOCHRON_TABLE_HEADERS = [
 TOTAL_PARAMS_HEADERS = [
     'Sequence', '', 'Mark',  # 0-2
     '(\u2074\u2070Ar/\u00B3\u2076Ar)t', '%1\u03C3',
-    '(\u2074\u2070Ar/\u00B3\u2076Ar)c', '%1\u03C3',  # 2-5
+    '(\u2074\u2070Ar/\u00B3\u2076Ar)c', '%1\u03C3',  # 3-6
     '(\u00B3\u2078Ar/\u00B3\u2076Ar)t', '%1\u03C3',
-    '(\u00B3\u2078Ar/\u00B3\u2076Ar)c', '%1\u03C3',  # 6-9
+    '(\u00B3\u2078Ar/\u00B3\u2076Ar)c', '%1\u03C3',  # 7-10
     '(\u00B3\u2079Ar/\u00B3\u2077Ar)Ca', '%1\u03C3',
     '(\u00B3\u2078Ar/\u00B3\u2077Ar)Ca', '%1\u03C3',
-    '(\u00B3\u2076Ar/\u00B3\u2077Ar)Ca', '%1\u03C3',  # 10-15
+    '(\u00B3\u2076Ar/\u00B3\u2077Ar)Ca', '%1\u03C3',  # 11-16
     '(\u2074\u2070Ar/\u00B3\u2079Ar)K', '%1\u03C3',
-    '(\u00B3\u2078Ar/\u00B3\u2079Ar)K', '%1\u03C3',  # 16-19
-    '(\u00B3\u2076Ar/\u00B3\u2078Ar)Cl', '%1\u03C3',  # 20-21
-    'K/Ca', '%1\u03C3', 'K/Cl', '%1\u03C3', 'Ca/Cl', '%1\u03C3',  # 22-27
-    'Cycle Number', 'Irradiation Cycles',  # 28-29
-    'Irradiation', 'duration', 'Irradiation Time', 'Experiment Time',  # 30-33
-    'Storage Years', '',  # 34-35
-    'Decay Constant \u2074\u2070K', '%1\u03C3',  # 36-37
-    'Decay Constant \u2074\u2070K(EC)', '%1\u03C3',  # 38-39
-    'Decay Constant \u2074\u2070K(\u03B2<sup>-</sup>)', '%1\u03C3',  # 40-41
-    'Decay Constant \u2074\u2070K(\u03B2<sup>+</sup>)', '%1\u03C3',  # 42-43
-    'Decay Constant \u00B3\u2079Ar', '%1\u03C3',  # 44-45
-    'Decay Constant \u00B3\u2077Ar', '%1\u03C3',  # 46-47
-    'Decay Constant \u00B3\u2076Cl', '%1\u03C3',  # 48-49
-    'Decay Activity \u2074\u2070K', '%1\u03C3',  # 50-51
-    'Decay Activity \u2074\u2070K(EC)', '%1\u03C3',  # 52-53
-    'Decay Activity \u2074\u2070K(\u03B2<sup>-</sup>)', '%1\u03C3',  # 54-55
-    'Decay Activity \u2074\u2070K(\u03B2<sup>+</sup>)', '%1\u03C3',  # 56-57
-    '\u00B3\u2076Cl/\u00B3\u2078Cl Productivity', '%1\u03C3',  # 58-59
-    'Std Name', 'Std Age', '1\u03C3', '\u2074\u2070Ar%', '1\u03C3', 'K%', '1\u03C3',  # 60-66
-    '\u2074\u2070Ar<sup>*</sup>/K', '1\u03C3',  # 67-68
-    'J', '%1\u03C3', 'MDF', '%1\u03C3',  # 69-72
-    'Mass \u00B3\u2076Ar', '%1\u03C3', 'Mass \u00B3\u2077Ar', '%1\u03C3',  # 73-76
-    'Mass \u00B3\u2078Ar', '%1\u03C3', 'Mass \u00B3\u2079Ar', '%1\u03C3',  # 77-80
-    'Mass \u2074\u2070', '%1\u03C3', 'K Mass', '%1\u03C3',  # 81-84
+    '(\u00B3\u2078Ar/\u00B3\u2079Ar)K', '%1\u03C3',  # 17-20
+    '(\u00B3\u2076Ar/\u00B3\u2078Ar)Cl', '%1\u03C3',  # 21-22
+    'K/Ca', '%1\u03C3', 'K/Cl', '%1\u03C3', 'Ca/Cl', '%1\u03C3',  # 23-28
+    'Cycle Number', 'Irradiation Cycles',  # 29-30
+    'Irradiation', 'duration', 'Irradiation Time', 'Experiment Time',  # 31-34
+    'Storage Years', '',  # 35-36
+    'Decay Constant \u2074\u2070K', '%1\u03C3',  # 37-38
+    'Decay Constant \u2074\u2070K(EC)', '%1\u03C3',  # 39-40
+    'Decay Constant \u2074\u2070K(\u03B2<sup>-</sup>)', '%1\u03C3',  # 41-42
+    'Decay Constant \u2074\u2070K(\u03B2<sup>+</sup>)', '%1\u03C3',  # 43-44
+    'Decay Constant \u00B3\u2079Ar', '%1\u03C3',  # 45-46
+    'Decay Constant \u00B3\u2077Ar', '%1\u03C3',  # 47-48
+    'Decay Constant \u00B3\u2076Cl', '%1\u03C3',  # 49-50
+    'Decay Activity \u2074\u2070K', '%1\u03C3',  # 51-52
+    'Decay Activity \u2074\u2070K(EC)', '%1\u03C3',  # 53-54
+    'Decay Activity \u2074\u2070K(\u03B2<sup>-</sup>)', '%1\u03C3',  # 55-56
+    'Decay Activity \u2074\u2070K(\u03B2<sup>+</sup>)', '%1\u03C3',  # 57-58
+    '\u00B3\u2076Cl/\u00B3\u2078Cl Productivity', '%1\u03C3',  # 59-60
+    'Std Name', 'Std Age', '1\u03C3', '\u2074\u2070Ar%', '1\u03C3', 'K%', '1\u03C3',  # 61-67
+    '\u2074\u2070Ar<sup>*</sup>/K', '1\u03C3',  # 68-69
+    'J', '%1\u03C3', 'MDF', '%1\u03C3',  # 70-73
+    'Mass \u00B3\u2076Ar', '%1\u03C3', 'Mass \u00B3\u2077Ar', '%1\u03C3',  # 74-77
+    'Mass \u00B3\u2078Ar', '%1\u03C3', 'Mass \u00B3\u2079Ar', '%1\u03C3',  # 78-81
+    'Mass \u2074\u2070', '%1\u03C3', 'K Mass', '%1\u03C3',  # 82-85
     'No', '%1\u03C3', 'Year', '%1\u03C3', '\u2074\u2070K/K', '%1\u03C3',
-    '\u00B3\u2075Cl/\u00B3\u2077Cl', '%1\u03C3', 'HCl/Cl', '%1\u03C3',  # 85-94
-    '\u2074\u2070Ar/\u00B3\u2076Ar air', '%1\u03C3',  # 95-96
-    '\u00B3\u2078Ar/\u00B3\u2076Ar air', '%1\u03C3',  # 97-98
-    'Isochron Fitting', 'Convergence', 'Iteration', 'Discrimination',  # 99-102
-    'Not Zero', 'Corr Blank', 'Corr Discr', 'Corr \u00B3\u2077Ar Decay',  # 103-106
-    'Corr \u00B3\u2079Ar Decay',  # 107
-    'Ca Degassing', 'K Degassing', 'Cl Degassing', 'Trap Degassing',  # 108-111
-    'Using Min Equation',  # 112
+    '\u00B3\u2075Cl/\u00B3\u2077Cl', '%1\u03C3', 'HCl/Cl', '%1\u03C3',  # 86-95
+    '\u2074\u2070Ar/\u00B3\u2076Ar air', '%1\u03C3',  # 96-97
+    '\u00B3\u2078Ar/\u00B3\u2076Ar air', '%1\u03C3',  # 98-99
+    'Isochron Fitting', 'Convergence', 'Iteration', 'Discrimination',  # 100-103
+    'Not Zero', 'Corr Blank', 'Corr Discr', 'Corr \u00B3\u2077Ar Decay',  # 104-107
+    'Corr \u00B3\u2079Ar Decay',  # 108
+    'Ca Degassing', 'K Degassing', 'Cl Degassing', 'Trap Degassing',  # 109-112
+    'Using Min Equation',  # 113
     # 'Recalibration', 'Using Std Age', 'Use Std Ratio',  # 112-115  to be completed
-    'Apply Gain Corr to Blanks',  # 113
-    '', '',  # 114-115
-    'Auto Plateau Method',  # 116 the index includes sequence name and unit
-    'Initial Ratio Model',  # 117
-    'Set1 initial Ratio',  # 118
-    '1\u03C3',  # 119
-    'Set2 initial Ratio',  # 120
-    '1\u03C3',  # 121
-    'Isotopic Errors',  # 122
-    'Parameter Errors',  # 123
-    'Plot Errors',  # 124
-    'Heating Time (s)',  # 125
-    'Heating Actual Temp (C)',  # 126
-    'Heating AT 1\u03C3',  # 127
-    '36Ar Gain', '%1\u03C3',  # 128-129
-    '37Ar Gain', '%1\u03C3',  # 130-131
-    '38Ar Gain', '%1\u03C3',  # 132-133
-    '39Ar Gain', '%1\u03C3',  # 134-135
-    '40Ar Gain', '%1\u03C3',  # 136-137
-    'Normalize Factor', '1\u03C3',  # 138-139
+    'Apply Gain Corr to Blanks',  # 114
+    '', '',  # 115-116
+    'Auto Plateau Method',  # 117 the index includes sequence name and unit
+    'Initial Ratio Model',  # 118
+    'Set1 initial Ratio',  # 119
+    '1\u03C3',  # 120
+    'Set2 initial Ratio',  # 121
+    '1\u03C3',  # 122
+    'Isotopic Errors',  # 123
+    'Parameter Errors',  # 124
+    'Plot Errors',  # 125
+    'Heating Time (s)',  # 126
+    'Heating Actual Temp (C)',  # 127
+    'Heating AT 1\u03C3',  # 128
+    '36Ar Gain', '%1\u03C3',  # 129-130
+    '37Ar Gain', '%1\u03C3',  # 131-132
+    '38Ar Gain', '%1\u03C3',  # 133-134
+    '39Ar Gain', '%1\u03C3',  # 135-136
+    '40Ar Gain', '%1\u03C3',  # 137-138
+    'Normalize Factor', '1\u03C3',  # 139-140
 ]
 
 SAMPLE_INTERCEPT_SHORT_HEADERS = [
@@ -1177,9 +1177,7 @@ class Sequence:
     def as_type(self, type_str):
         if str(type_str).lower() in ["blk", "b", "blank"]:
             self.type_str = "blank"
-        if str(type_str).lower() in ["a", "air"]:
-            self.type_str = "air"
-        if self.type_str not in ["blank", "air"]:
+        else:
             self.type_str = "unknown"
 
     __as_type = as_type
@@ -1188,10 +1186,7 @@ class Sequence:
         return self.type_str == "blank"
 
     def is_unknown(self):
-        return self.type_str != "blank" and self.type_str != "air"
-
-    def is_air(self):
-        return self.type_str == "air"
+        return self.type_str != "blank"
 
     def as_blank(self):
         return self.as_type("blank")
@@ -1199,9 +1194,6 @@ class Sequence:
     def as_unknown(self):
         return self.as_type("unknown")
 
-    def as_air(self):
-        return self.as_type("air")
-
     def get_data_df(self):
         ...
 
@@ -1230,7 +1222,7 @@ class RawData:
         self.unit = unit
         self.isotopic_num = isotopic_num
         self.sequence_num = sequence_num
-        self.interpolated_blank = None
+        self.interpolated_blank = []
         if sequence is not None:
             self.sequence = sequence
         elif data is not None:
@@ -1241,7 +1233,7 @@ class RawData:
                     data=item[1:],
                     datetime=item[0][1],
                     fitting_method=[*kwargs.get("fitting_method", [0] * 5)],
-                    options=item[0][2]
+                    options=item[0][2],
                 ) for index, item in enumerate(data)]
         else:
             self.sequence: List[Sequence] = []
@@ -1275,8 +1267,5 @@ class RawData:
     def get_blank(self) -> Union[Sequence, List]:
         ...
 
-    def get_air(self) -> Union[Sequence, List]:
-        ...
-
     def to_sample(self, mapping: Optional[List[dict]]) -> Sample:
         ...

ararpy/smp/style.py

@@ -64,7 +64,10 @@ def set_plot_style(smp: Sample):
     # Auto position and contents of texts
     reset_text(smp)
     # Set title, which are deleted in initializing
-    suffix = f"{smp.Info.sample.name} {smp.Info.sample.material}"
+    exp_name = smp.Info.experiment.name
+    smp_name = smp.Info.sample.name
+    name = f"{exp_name} {smp_name}" if str(exp_name).lower().strip() != str(smp_name).lower().strip() else exp_name
+    suffix = f"{name} {smp.Info.sample.material}"
     for figure_id, figure in basic.get_components(smp).items():
         if isinstance(figure, Plot):
             if not hasattr(figure, 'title'):

{ararpy-0.1.35.dist-info → ararpy-0.1.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ararpy
-Version: 0.1.35
+Version: 0.1.37
 Summary: A project for Ar-Ar geochronology
 Home-page: https://github.com/wuyangchn/ararpy.git
 Author: Yang Wu

{ararpy-0.1.35.dist-info → ararpy-0.1.37.dist-info}/RECORD

@@ -5,20 +5,20 @@ ararpy/Example - Show MDD results.py,sha256=YFkiQual60lyCClsfvivr4REY6waSYuomf0u
 ararpy/Example - Show all Kfs age spectra.py,sha256=1edPtBpFfS0lC7vLnLu34mDHt_xjbc8ptk6rZ--pf-I,12304
 ararpy/Example - Show random walk results.py,sha256=8WWvbAI7ySiMR-XwtFe5kTQihW3mcqzL3S7EUZdoxYo,15477
 ararpy/Example - Tc calculation.py,sha256=sD9pu3IaZ8mBV95rV2wOEhlQUexFNqBUoBqnNMdUBis,19617
-ararpy/__init__.py,sha256=QNjq0E-Eb31ghGZnPcKrb6Rb7jydq3mmxICzg8As4yc,6857
+ararpy/__init__.py,sha256=lguPXqCx66J1evLooyi_UF-O_dMUDWl4sH8z5VlpGns,6768
 ararpy/test.py,sha256=4F46-JJ1Ge12HGae0qO44Qc6kiEMHBgn2MsY_5LlHDo,3973
 ararpy/calc/__init__.py,sha256=kUjRuLE8TLuKOv3i976RnGJoEMj23QBZDu37LWs81U4,322
 ararpy/calc/age.py,sha256=WOZs70zXiBWDIEhXJLIaNiYTOFJNk0NDbH5e5zCbCks,5435
 ararpy/calc/arr.py,sha256=jD1Fd0Cj3xc7NqgnG4cp3VWQWxUlV0qCtPBZZokDG8o,15246
-ararpy/calc/basic.py,sha256=X8BoAjZgk52WfAbhOCUTEOkDIdSuz21gepN-Xke4oGA,4165
+ararpy/calc/basic.py,sha256=2Iqk5WBMH8hiOqW2cvyPNEAbGU7hoeGTQ08Y6mlyfv8,4550
 ararpy/calc/corr.py,sha256=QDitvLf6y5IBpHtVEJfOUVjWSlIP9qJ4Jhluk9eDEDE,18801
 ararpy/calc/err.py,sha256=63LtprqjemlIb1QGDst4Ggcv5KMSDHdlAIL-nyQs1eA,2691
 ararpy/calc/histogram.py,sha256=0GVbDdsjd91KQ1sa2B7NtZ4KGo0XpRIJapgIrzAwQUo,5777
 ararpy/calc/isochron.py,sha256=ej9G2e68k6yszonWHsLcEubh3TA7eh1upTJP_X0ttAA,5726
 ararpy/calc/jvalue.py,sha256=OL5zPYU8Pac-wOxUWPCgu3onh2n01xDnhpi2mlUsjJM,1146
 ararpy/calc/plot.py,sha256=Hdtb-q18xYC8ZJeDKGRauCSbj4_7e6Z8HQs9aYgfvao,2139
-ararpy/calc/raw_funcs.py,sha256=GJ0VW0sc2qPIVp5jSDmPP1ClOoYRa_cc35ye7QDYOiI,2744
-ararpy/calc/regression.py,sha256=DRyikpeqmImz65pQcYe0m78t_XVy3DA4L0jGJIb9AVU,39800
+ararpy/calc/raw_funcs.py,sha256=Rza1nIBQCOlJK_X0XvzmJqNG_byuaZxotNbdM84M-gI,2736
+ararpy/calc/regression.py,sha256=m2_xJAsQ7mBIbnrmxtSPIQapJH61jkxvXskxN-8f86k,42803
 ararpy/calc/spectra.py,sha256=_Q23eP9necHlaCoHf3_UfW1N3JmVZj5rcWFro8GS-CA,1995
 ararpy/examples/022_VU124-M11a.ahd,sha256=3m0Gd-ZObou3KsnRNFMf77QwzT1Uz3nu3vA33Sqeyng,5414
 ararpy/examples/20WHA0103.age,sha256=cT-a4d7Wt77aotx6v0G47vulY_TZIcZUcaVHB3pqTPM,380416
@@ -42,9 +42,9 @@ ararpy/examples/sample-default.smp,sha256=YNkoQGgPrsL_fXS7ZHxfRtLQWekCDqT9czS6vB
 ararpy/files/__init__.py,sha256=l5B5ZQ01WdtvjjN0aMkyAFNgpwANdM_1I0tQbqnRuEY,69
 ararpy/files/arr_file.py,sha256=pD5MxkAydL7cNq2wmKFUaOU4jHhc3MzTYrwbxZ3f46w,881
 ararpy/files/basic.py,sha256=k2GXgZjhqSmKvpXQLjsXDksS_ZLvqD7AWW54fXnYvTI,1228
-ararpy/files/calc_file.py,sha256=RrfMo7Q8-4pBMQdpGY0guF52aSqAk8LEjq2NE3toL2w,28734
+ararpy/files/calc_file.py,sha256=bapIVd3QQBprdMdfxNbY8TJH1UkfphIUtim3ONypc3I,28779
 ararpy/files/new_file.py,sha256=efblARIBROVLWS2w3-98BxLX5VZ8grRpiTkJFtf_rAk,214
-ararpy/files/raw_file.py,sha256=-XFrWdkxvB3JLBCFGWIX6FL-2DtKPhfIA3loF1wCoP4,21962
+ararpy/files/raw_file.py,sha256=iaM53pUHD3-sIgrRA_jXNOn5KIdKxKLEur_0DxNVPLo,20445
 ararpy/files/xls.py,sha256=DVcZ_yRnc19p-m4leGGjt-YPDpSa2udYKmGyrM0qub0,640
 ararpy/smp/EXPORT_TO_PDF_DATA_PROPERTIES.py,sha256=baDM437tu6hsPv0uYfod0TREXlPd6kvMBFT1S9ZZlkk,3024
 ararpy/smp/__init__.py,sha256=k6_fa27UJsQK7K7oC5GYlwMo6l0Xd8af3QtOrZz2XJk,478
@@ -54,20 +54,20 @@ ararpy/smp/consts.py,sha256=XIdjdz8cYxspG2jMnoItdlUsxr3hKbNFJjMZJh1bpzw,393
 ararpy/smp/corr.py,sha256=U5K1Vld55IHea_fZ7EEY_8dkvjp0f6OhpdSxf7b9WGY,26551
 ararpy/smp/diffusion_funcs.py,sha256=NC5T0GYXCidgVqSy3BGmIroLWzQhyzYb5x4gg_L0dJ4,186694
 ararpy/smp/export.py,sha256=yAUlTvFBo2U703hZ79NlAcTYC7QZGXHUn_IRP7sQuRA,120638
-ararpy/smp/info.py,sha256=iKUELm-BuUduDlJKC1d8tKKNHbwwbNmhUg2pi6bcBvA,489
-ararpy/smp/initial.py,sha256=QGk7vh7JyVqalwnpd9VudQoX2Z9tyWzfIIw_cL5Sok0,18031
-ararpy/smp/json.py,sha256=BTZCjVN0aj9epc700nwkYEYMKN2lHBYo-pLmtnz5oHY,2300
+ararpy/smp/info.py,sha256=tpEIjrE4nR-GAYTricBk9gq0LuHh6F1Bt7HPo1rS2HM,497
+ararpy/smp/initial.py,sha256=4-ojO-_Dmuyt-W1Ueji3FYPSSAZrOZ2ZxyGxmar3Kn8,18203
+ararpy/smp/json.py,sha256=zfJCC_2LCDckqC8Fpu10jEA6Knl3UtKO31I5g4fvsBE,2273
 ararpy/smp/plots.py,sha256=fFuJxoFcnvGSysjdEdrbW_ITpukt0iGs2K25gshIKNU,33594
-ararpy/smp/raw.py,sha256=SeKaNZZRWjiE_7fMHwn1IgQxX17t8mNFYMnRiimMLRU,6474
-ararpy/smp/sample.py,sha256=iaFjG0S0GuNwbLeUFpzEFIbqa0oX0KekRZuLJd2mSCQ,58903
-ararpy/smp/style.py,sha256=Q8f6SsqnxmzocxpZUyGDiNanVW0ijCZpxHKh19UIeoM,7800
+ararpy/smp/raw.py,sha256=77J1dEYL4ZSeftp4tyog_Cy1Y5bwHNaLqJK4i4KLOSY,6500
+ararpy/smp/sample.py,sha256=P3lh2kOThTGrtNNgPF02y6_9ORM6mAlMSwEsPxLQAwM,58566
+ararpy/smp/style.py,sha256=y0iQpN4jy3PGy31DG5-_P1fNFGgyUNdsJX9qlYGVMEM,7979
 ararpy/smp/table.py,sha256=Vq3GK9aslEuBhmvlQoUHjcs71Q6raSFYqd5veB1L9mk,6887
 ararpy/thermo/__init__.py,sha256=6VBuqTRFl403PVqOuMkVrut0nKaQsAosBmfW91X1dMg,263
 ararpy/thermo/arrhenius.py,sha256=Ass1ichHfqIAtpv8eLlgrUc1UOb3Urh1qzr1E3gLB4U,233
 ararpy/thermo/atomic_level_random_walk.py,sha256=ncw9DtxRfS6zlQbLVLNX7WNoO9sX_nSomwAsTH0_O3k,25910
 ararpy/thermo/basic.py,sha256=JJRZbYmvXlpRAV2FeFPwLhrig4ZhNQmJnWqgOjo-1YQ,11508
-ararpy-0.1.35.dist-info/licenses/LICENSE,sha256=cvG5t_C1qY_zUyJI7sNOa7gCArdngNPaOrfujl2LYuc,1085
-ararpy-0.1.35.dist-info/METADATA,sha256=otZdi9PduAn5szYirVk7APLhRBKUnyIXRIkDvsanvDk,24516
-ararpy-0.1.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ararpy-0.1.35.dist-info/top_level.txt,sha256=9iTpsPCYuRYq09yQTk9d2lqB8JtTEOmbN-IcGB-K3vY,7
-ararpy-0.1.35.dist-info/RECORD,,
+ararpy-0.1.37.dist-info/licenses/LICENSE,sha256=cvG5t_C1qY_zUyJI7sNOa7gCArdngNPaOrfujl2LYuc,1085
+ararpy-0.1.37.dist-info/METADATA,sha256=CWUoNZxPs8oUAPXtcOFXxylMCwE21PMamMv_oEm-juM,24516
+ararpy-0.1.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ararpy-0.1.37.dist-info/top_level.txt,sha256=9iTpsPCYuRYq09yQTk9d2lqB8JtTEOmbN-IcGB-K3vY,7
+ararpy-0.1.37.dist-info/RECORD,,