ararpy 0.0.24__py3-none-any.whl → 0.1.11__py3-none-any.whl

ararpy/__init__.py

@@ -29,10 +29,11 @@ from_full = smp.initial.from_full_files
 from_raw = smp.initial.from_raw_files
 from_empty = smp.initial.from_empty
 
+save = lambda _smp, _path: files.arr_file.save(_path, _smp)
+
 """ Classes """
 
 Sample = smp.Sample
-Info = smp.Info
 Table = smp.Table
 Plot = smp.Plot
 Set = smp.Set
@@ -51,7 +52,7 @@ ArArData.to_list = lambda _ad: _ad.data
 
 """ Sample Class Methods """
 
-Sample.name = lambda _smp: _smp.Info.sample.name
+Sample.name = smp.info.name
 Sample.doi = lambda _smp: _smp.Doi
 Sample.sample = lambda _smp: _smp.Info.sample
 Sample.researcher = lambda _smp: _smp.Info.researcher
@@ -115,9 +116,6 @@ Sample.plot_cl_3 = lambda _smp: smp.calculation.recalculate(
 Sample.plot_3D = lambda _smp: smp.calculation.recalculate(
     _smp, re_plot=True, isIsochron=True, isInit=False, isPlateau=False, figures=['figure_7'])
 
-# export functions
-Sample.to_pdf = lambda _smp, file_path, figure: smp.export.to_pdf(file_path, figure, _smp)
-
 Sample.show_data = lambda _smp: \
     f"Sample Name: \n\t{_smp.name()}\n" \
     f"Doi: \n\t{_smp.doi()}\n" \

ararpy/calc/age.py

@@ -111,9 +111,9 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
 
     # change to Ma
     # analytical error, error of 40Ar/39Ar only
-    s1 = np.sqrt((V * KK * R / (R * XX)) ** 2 * sR_2 ** 2) / 1000000
+    s1 = np.sqrt((V * KK * BB / XX) ** 2 * sR_2 ** 2) / 1000000
     # internal error, errors of 40Ar/39Ar and J value
-    s2 = np.sqrt((V * KK * R / (R * XX)) ** 2 * sR_1 ** 2) / 1000000
+    s2 = np.sqrt((V * KK * BB / XX) ** 2 * sR_1 ** 2) / 1000000
     # total external error
     s3 = np.sqrt(e1 + e2 + e3 + e4 + e5 + e6 + e7 + e8 + e9) / 1000000
     age = k0 / 1000000

ararpy/calc/arr.py

@@ -40,15 +40,13 @@ def mul(*args):
     -------
     2D list, [values, errors]
     """
-    n = np.shape([args])[-1]
-    k0, k1 = [1] * n, [0] * n
-    k2 = []
-    for i in range(n):
-        for arg in args:
-            k0[i] = np.multiply(k0[i], arg[0][i])
-            k1[i] = k1[i] + np.divide(arg[1][i] ** 2, arg[0][i] ** 2)
-        k2.append(abs(k0[i]) * k1[i] ** .5)
-    return [k0, k2]
+    v = np.array(args)
+    res = np.zeros([2, v.shape[-1]], dtype=np.float64)
+    for i in range(v.shape[-1]):
+        res[0, i] = np.prod(v[:, 0, i])
+        res[1, i] = err.mul(*v[:, :, i])
+
+    return res
 
 
 def div(a, b):
@@ -128,7 +126,7 @@ def sub(*args):
     -------
 
     """
-    args = np.array(args)
+    args = np.array(args, dtype=np.float64)
     args[np.isnan(args)] = 0
     n = np.shape(args)[-1]
     k0, k1 = [], []
@@ -213,14 +211,15 @@ def partial(a: list, rows=None, cols=None):
     except ValueError:
         # ValueError, the requested array has an inhomogeneous shape
         return partial(homo(a), rows=rows, cols=cols)
+    default_col = [np.nan for i in range(n)]
     if rows is None:
         rows = list(range(n))
     if cols is None:
         cols = list(range(m))
     if isinstance(cols, list):
-        res = [a[i] for i in cols]
+        res = [a[i] if i != -1 else default_col for i in cols]
     elif isinstance(cols, int):
-        res = a[cols]
+        res = a[cols] if cols != -1 else default_col
     if isinstance(rows, list):
         if isinstance(cols, list):
             res = [[i[j] for j in rows] for i in res]
@@ -493,7 +492,7 @@ def transpose(obj, ignore: bool = True):
     Parameters
     ----------
     obj : two dimensional list-like object
-    ignore : return obj if ingore error is true
+    ignore : return obj if ignore error is true
 
     Returns
     -------
@@ -506,20 +505,22 @@ def transpose(obj, ignore: bool = True):
         m, n = np.shape(obj)
         return [[obj[i][j] for i in range(m)] for j in range(n)]
     except (ValueError, TypeError):
-        # print(traceback.format_exc())
+        print(traceback.format_exc())
         if ignore:
             return obj
+        else:
+            raise ValueError
 
 
 def get_item(obj: list, loc: (list, tuple, int), default: Union[str, int, float, bool] = None,
-             based: int = 0) -> Union[str, int, float, bool]:
+             base: Union[int, tuple, list] = 0) -> Union[str, int, float, bool]:
     """ Get item from a n-dimension list
     Parameters
     ----------
     obj
     loc
     default
-    based
+    base
 
     Returns
     -------
@@ -528,13 +529,16 @@ def get_item(obj: list, loc: (list, tuple, int), default: Union[str, int, float,
         if not isinstance(obj, list):
             raise TypeError
         if isinstance(loc, int):
-            return obj[loc - based if loc - based >= 0 else 0]
+            loc = [loc]
+        if isinstance(base, int):
+            base = [base for i in range(len(loc))]
         if len(loc) == 1:
-            return obj[loc[0] - based if loc[0] - based >= 0 else 0]
-        return get_item(obj[loc[0] - based if loc[0] - based >= 0 else 0], loc[1:], based=based)
+            return obj[loc[0] - base[0]] if loc[0] - base[0] >= 0 else ""
+        if loc[0] - base[0] < 0:
+            raise IndexError
+        return get_item(obj[loc[0] - base[0]], loc[1:], base=base[1:], default=default)
     except (IndexError, TypeError, ValueError):
-        if default is not None:
-            return default
+        return default
     raise ValueError(f"Cannot get a item from {obj = }, {loc = }")
 
 

ararpy/calc/basic.py

@@ -48,6 +48,8 @@ def merge_dicts(a: dict, b: dict):
     """
     res = copy.deepcopy(a)
     for key, val in b.items():
+        if key not in res.keys() and key.isnumeric():
+            key = int(key)
         if key not in res.keys():
             res[key] = val
         elif isinstance(val, dict):
@@ -55,3 +57,24 @@ def merge_dicts(a: dict, b: dict):
         else:
             continue
     return res
+
+
+def update_dicts(a: dict, b: dict):
+    """
+    a and b, two dictionary. Return updated a
+        For example:
+            a = {"1": 1, "2": {"1": 1, "2": 2, "3": 3, "5": {}, "6": [1, 2]}}
+            b = {"1": 'b', "2": {"1": 'b', "2": 'b', "3": 'b', "4": 'b', "5": {"1": 'b'}, "6": [1, 2, 3]}}
+            Will return {'1': 'b', ...}
+    """
+    res = copy.deepcopy(a)
+    for key, val in b.items():
+        if key not in res.keys() and key.isnumeric():
+            key = int(key)
+        if key not in res.keys():
+            res[key] = val
+        elif isinstance(val, dict):
+            res[key] = update_dicts(res[key], val)
+        else:
+            res[key] = val
+    return res

ararpy/calc/corr.py

@@ -51,7 +51,7 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
     if isAapkop:
         # line
         k1 = (ra / rm + delta_m - 1) / delta_m  # A.A.P.Koppers
-        k2 = arr.div(((ra / rm + delta_m - 1), arr.div((ra, sra), (rm, srm))), (delta_m, sdelta_m))
+        k2 = err.div(((ra / rm + delta_m - 1), err.div((ra, sra), (rm, srm))), (delta_m, sdelta_m))
         # exp
         try:
             k3 = (np.log(ra / rm) / np.log(ratio_m)) * (1 / m1) + 1  # A.A.P.Koppers
@@ -230,7 +230,7 @@ def get_irradiation_datetime_by_string(datetime_str: str):
 
     """
     res = []
-    if datetime_str == '' or datetime_str is None:
+    if datetime_str == '' or datetime_str is None or (isinstance(datetime_str, float) and np.isnan(datetime_str)):
         return ['', 0]
     cycles = datetime_str.split('S')
     for cycle in cycles:
@@ -252,8 +252,8 @@ def get_method_fitting_law_by_name(method_str: str):
     res = [False] * 3
     try:
         res[['Lin', 'Exp', 'Pow'].index(method_str.capitalize()[:3])] = True
-    except ValueError:
-        res[0] = True
+    except (ValueError, AttributeError):
+        pass
     return res
 
 
@@ -379,9 +379,11 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
             _ar36cl = (_ar36res - _ar38res / R38v36a[i]) / (1 - 1 / (R36v38clp[i] * (1 - exp(-1 * L36cl[i] * stand_time_year)) * R38v36a[i]))
             _ar36a = _ar36res - _ar36cl
             _ar40r = (ar40m[i] - ar40b[i]) * P40Mdf - _ar36a * R40v36a[i] - _ar39k * R40v39k[i]
+            _ar40ar = (ar40m[i] - ar40b[i]) * P40Mdf - _ar39k * R40v39k[i]
             _f = _ar40r / _ar39k
             i += 1
-            yield _f, _ar36, _ar37, _ar38, _ar39, _ar40, _ar36a, _ar37ca, _ar39k, _ar40r, _ar36cl
+            # yield _f, _ar36, _ar37, _ar38, _ar39, _ar40, _ar36a, _ar37ca, _ar39k, _ar40r, _ar36cl
+            yield _f, _ar36a, _ar39k, _ar40ar
 
     simulation = do_simulation()
     F = []
@@ -396,18 +398,27 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     ar39k = []
     ar40r = []
     ar36cl = []
+
+    nor_x = []
+    nor_y = []
+    inv_x = []
+    inv_y = []
     for each in simulation:
         F.append(each[0])
-        ar36.append(each[1])
-        ar37.append(each[2])
-        ar38.append(each[3])
-        ar39.append(each[4])
-        ar40.append(each[5])
-        ar36a.append(each[6])
-        ar37ca.append(each[7])
-        ar39k.append(each[8])
-        ar40r.append(each[9])
-        ar36cl.append(each[10])
+        nor_x.append(each[2] / each[1])
+        nor_y.append(each[3] / each[1])
+        inv_x.append(each[2] / each[3])
+        inv_y.append(each[1] / each[3])
+        # ar36.append(each[1])
+        # ar37.append(each[2])
+        # ar38.append(each[3])
+        # ar39.append(each[4])
+        # ar40.append(each[5])
+        # ar36a.append(each[6])
+        # ar37ca.append(each[7])
+        # ar39k.append(each[8])
+        # ar40r.append(each[9])
+        # ar36cl.append(each[10])
 
     # print("F = {0} ± {1}".format(np.mean(F), np.std(F)))
     #
@@ -443,8 +454,12 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     #     f.writelines("\n".join([str(i) for i in ar39k]))
     # with open("ar40r.txt", 'w') as f:  # save serialized json data to a readable text
     #     f.writelines("\n".join([str(i) for i in ar40r]))
-
-    return np.mean(F), np.std(F)
+    # F, sF,
+    return np.mean(F), np.std(F), \
+           np.mean(nor_x), np.std(nor_x), np.mean(nor_y), np.std(nor_y), \
+           np.cov(nor_x, nor_y)[0][1] / (np.std(nor_x) * np.std(nor_y)), \
+           np.mean(inv_x), np.std(inv_x), np.mean(inv_y), np.std(inv_y), \
+           np.cov(inv_x, inv_y)[0][1] / (np.std(inv_x) * np.std(inv_y))
 
 
 

ararpy/calc/err.py

@@ -36,8 +36,15 @@ def mul(*args: tuple) -> float:
     Returns: float, propagated error
 
     """
-    k = abs(np.prod([arg[0] for arg in args])) * sum([np.divide(arg[1] ** 2, arg[0] ** 2) for arg in args]) ** .5
-    return k
+    # k = abs(np.prod([arg[0] for arg in args])) * sum([np.divide(arg[1] ** 2, arg[0] ** 2) for arg in args]) ** .5
+    v = np.ma.array(args, mask=False)
+    k = 0
+    for i in range(v.shape[0]):
+        v.mask[i, 0] = True
+        k += np.prod(v[:, 0]) ** 2 * v[i, 1] ** 2
+        v.mask[i, 0] = False
+
+    return np.sqrt(k)
 
 
 def rec(a: tuple) -> float:

ararpy/calc/jvalue.py

@@ -12,7 +12,7 @@
 import numpy as np
 
 
-def j_value(age: float, sage: float, r: float, sr: float, f: float, rsf: float):
+def j_value(age, sage, r, sr, f, rsf):
     """ Calculate J value according to the given age and the ratio
 
     Parameters
@@ -28,11 +28,12 @@ def j_value(age: float, sage: float, r: float, sr: float, f: float, rsf: float):
     -------
     tuple of  J value and error
     """
+    age, sage, r, sr, f, rsf = np.array([age, sage, r, sr, f, rsf])
     f = f * 1000000  # exchange to unit of Ma
     rsf = f * rsf / 100  # exchange to absolute error
     k0 = (np.exp(f * age) - 1) / r
     v1 = rsf ** 2 * (age * np.exp(f * age) / r) ** 2
     v2 = sage ** 2 * (f * np.exp(f * age) / r) ** 2
     v3 = sr ** 2 * ((1 - np.exp(f * age)) / r ** 2) ** 2
-    k1 = pow(v1 + v2 + v3, 0.5)
+    k1 = np.sqrt(v1 + v2 + v3)
     return k0, k1

ararpy/calc/raw_funcs.py

@@ -33,7 +33,6 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
     #     unselected = []
     # linesData = []
     linesResults, regCoeffs = [], []
-    x, y = transpose(points_data)
     # un_x = transpose(unselected)[0] if is_twoD(unselected) else []
     reg_handler = [
         regression.linest, regression.quadratic, regression.exponential,
@@ -42,6 +41,7 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
     # lines_x = [(max(x + un_x) - 0) / size * i for i in range(size + 1)]
     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

@@ -18,9 +18,13 @@ import pandas as pd
 from scipy.stats import distributions
 from scipy.optimize import fsolve
 import warnings
+from scipy.optimize import minimize
 warnings.simplefilter(action="ignore", category=RuntimeWarning)
 
 
+""" regression functions for isochrons """
+
+
 def york2(x: list, sx: list, y: list, sy: list, ri: list, f: int = 1,
           convergence: float = 0.001, iteration: int = 100):
     """
@@ -107,7 +111,7 @@ def york2(x: list, sx: list, y: list, sy: list, ri: list, f: int = 1,
     chi_square = mswd * (n - 2)
     p_value = distributions.chi2.sf(chi_square, n - 2)
     # average error of S
-    err_s = lambda m, b: list(map(lambda Zi, Yi, Xi: (1 / Zi) ** 1./2. / abs(Yi - m * Xi - b), Z(m, b), y, x))
+    err_s = lambda m, b: list(map(lambda Zi, Yi, Xi: (1 / Zi) ** (1./2.) / abs(Yi - m * Xi - b), Z(m, b), y, x))
     avg_err_s = sum(err_s(m, b)) / len(x) * 100
 
     # print('----------------------------------------------------------------')
@@ -402,6 +406,62 @@ def wtd_3D_regression_df(data: pd.DataFrame, f: int = 1, convergence: float = 0.
     return res
 
 
+def max_likelihood(x: list, sx: list, y: list, sy: list, ri: list):
+    """
+    Parameters
+    ----------
+    x
+    sx
+    y
+    sy
+    ri
+
+    Returns
+    -------
+
+    """
+
+    # 定义线性模型
+    def linear_model(params, _x):
+        return params[0] * _x + params[1]
+
+    # 定义负对数似然函数
+    def negative_log_likelihood(params, _x, _y):
+        predicted_y = linear_model(params, _x)
+        # 使用高斯误差进行似然计算
+        errors = predicted_y - _y
+        likelihood = np.sum(-0.5 * np.log(2 * np.pi) - 0.5 * errors ** 2)
+        return -likelihood
+
+    initial = linest(y, x)[5]
+    res = minimize(negative_log_likelihood, initial, args=(np.array(x), np.array(y)))
+    slope, intercept = res.x
+    return intercept, 0, slope, 0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+
+
+def olst(x: list, sx: list, y: list, sy: list, ri: list):
+    """
+    Parameters
+    ----------
+    x
+    sx
+    y
+    sy
+    ri
+
+    Returns
+    -------
+
+    """
+
+    res = linest(y, x)
+    # b, sb, m, sm, mswd, m - last m, Di, k, r2,
+    return *res[:2], res[5][1], res[6][1], np.nan, np.nan, np.nan, np.nan, res[3], np.nan, np.nan, np.nan
+
+
+""" regression functions for raw data """
+
+
 def linest(a0: list, a1: list, *args):
     """
     Parameters
@@ -449,7 +509,7 @@ def linest(a0: list, a1: list, *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, 'mswd', beta, se_beta, get_adjusted_y, m_ssresid
+    return beta[0], se_beta[0], rse_beta[0] * 100, r2, m_ssresid, beta, se_beta, get_adjusted_y, m_ssresid
 
 
 def average(a0: list, a1=None):
@@ -695,10 +755,10 @@ 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, [b, m], [seb, sem] = k[0:7]
+    b, seb, rseb, r2, mswd, beta, se_beta = k[0:7]
 
     def get_adjusted_y(x: list):
-        return [b + sum([m * _x ** (i + 1) for i in range(degree)]) for _x in x]
+        return [sum([beta[i] * _x ** i for i in range(degree + 1)]) for _x in x]
 
     k[7] = get_adjusted_y
 

ararpy/files/basic.py

@@ -21,8 +21,8 @@ def upload(file, media_dir):
         name, suffix = os.path.splitext(file.name)
         if suffix.lower() not in [
             '.xls', '.age', '.xlsx', '.arr', '.jpg', '.png', '.txt',
-            '.log', '.seq', '.json', '.ahd']:
-            raise TypeError("Wrong File")
+            '.log', '.seq', '.json', '.ahd', '.csv']:
+            raise TypeError(f"The imported file is not supported: {suffix}")
         web_file_path = os.path.join(media_dir, file.name)
         with open(web_file_path, 'wb') as f:
             for chunk in file.chunks():

ararpy/files/calc_file.py

@@ -35,8 +35,7 @@ def read_calc_file(file_path: str):
     try:
         with open(file_path, 'rb') as file:
             office_file = msoffcrypto.OfficeFile(file)
-            office_file.load_key(password=bytes.fromhex(
-                open(os.path.join(os.path.dirname(__file__), '../../conf.txt'), "r").read()).decode())
+            office_file.load_key(password=bytes.fromhex('6161706b6f70').decode())
             office_file.decrypt(open(decrypt_file_path, 'wb'))
         wb = open_workbook(decrypt_file_path)
         worksheets = wb.sheet_names()