ararpy 0.1.199__py3-none-any.whl → 0.2.1__py3-none-any.whl

ararpy/calc/corr.py

@@ -61,10 +61,10 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
     sratio_m = err.div((m2, sm2), (m1, sm1))
     useRyu = False
     if not useRyu:
-        # line
-        k1 = (ra / rm + delta_m - 1) / delta_m
-        k2 = err.div(((ra / rm + delta_m - 1), err.div((ra, sra), (rm, srm))), (delta_m, sdelta_m))
-        # exp
+        # line, D = 1 + (ra / rm - 1) / dm  # Renne2009
+        k1 = 1 + (ra / rm - 1) / delta_m
+        k2 = err.div(((ra / rm - 1), err.div((ra, sra), (rm, srm))), (delta_m, sdelta_m))
+        # exp, D = 1 + ln(ra / rm) / (m1 * ln(m2/m1))  # Renne2009
         try:
             k3 = (np.log(ra / rm) / np.log(ratio_m)) * (1 / m1) + 1
             v1 = err.log((ra / rm, err.div((ra, sra), (rm, srm))))
@@ -73,7 +73,7 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
             k4 = err.div((np.log(ra / rm) / np.log(ratio_m), v3), (m1, sm1))
         except Exception:
             k3, k4 = 0, 0
-        # pow
+        # pow, D = pow(ra / rm, 1 / dm)  # Renne2009
         try:
             k5 = pow((ra / rm), (1 / delta_m))  # Renne2009, B.D. Turrin2010
             k6 = err.pow((ra / rm, err.div((ra, sra), (rm, srm))),
@@ -86,8 +86,7 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
         return mdf_line_2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
 
-def discr(a0: list, e0: list, mdf: list, smdf: list, m: list, m40: list,
-          isRelative=True, method="l"):
+def discr(a0: list, e0: list, mdf: list, smdf: list, m: list, m40: list, method: list, isRelative=True):
     """
     :param a0: a list of tested isotope value
     :param e0: 1 sigma error of a0, list type
@@ -101,25 +100,29 @@ def discr(a0: list, e0: list, mdf: list, smdf: list, m: list, m40: list,
     linear correction, MDF = [(Ar40/Ar36)true / (Ar40/Ar36)measure] * 1 / MD - 1 / MD + 1
     corr = blank_corrected / [MD * MDF - MD +1]
     """
+
+    def _discr(_mdf: float, _smdf: float, _m40: float, _m: float, _method: str):
+        delta_m = abs(_m40 - _m)
+        ratio_m = abs(_m40 / _m) if _m != 0 else 1
+        if _method.lower().startswith("l"):  # linear
+            k0 = 1 / (delta_m * _mdf - delta_m + 1) if (delta_m * _mdf - delta_m + 1) != 0 else 0
+            k1 = err.rec((delta_m * _mdf - delta_m + 1, _smdf * delta_m))
+        elif _method.lower().startswith("e"):  # exponential
+            k0 = 1 / np.exp((_mdf - 1) * _m * ratio_m)
+            k1 = err.rec((1 / k0, err.pow((np.e, 0), ((_mdf - 1) * _m * np.log(ratio_m), err.mul((_mdf - 1, _smdf), (_m * np.log(ratio_m), 0))))))
+        elif _method.lower().startswith("p"):  # power
+            k0 = 1 / (_mdf ** delta_m)
+            k1 = err.rec((_mdf ** delta_m, err.pow((_mdf, _smdf), (delta_m, 0))))
+        else:
+            k0 = 1
+            k1 = 0
+        return k0, k1
+
     r0, r1 = [], []
     if isRelative:
         smdf = [smdf[i] * mdf[i] / 100 for i in range(len(smdf))]
     for i in range(min([len(arg) for arg in [a0, e0, mdf, smdf]])):
-        delta_mass = abs(m40[i] - m[i])
-        ratio_mass = abs(m40[i] / m[i]) if m[i] != 0 else 1
-        if method.lower().startswith("l"):
-            k0 = 1 / (delta_mass * mdf[i] - delta_mass + 1) if (delta_mass * mdf[i] - delta_mass + 1) != 0 else 0
-            k1 = err.div((1, 0), (delta_mass * mdf[i] - delta_mass + 1, smdf[i] * delta_mass))
-        elif method.lower().startswith("e"):
-            k0 = 1 / (ratio_mass ** (mdf[i] * m40[i] - m[i]))
-            k1 = err.div((1, 0), (ratio_mass ** (mdf[i] * m40[i] - m[i]), err.pow((ratio_mass, 0), (
-                mdf[i] * m40[i] - m[i], err.mul((mdf[i], smdf[i]), (m40[i], 0))))))
-        elif method.lower().startswith("p"):
-            k0 = 1 / (mdf[i] ** delta_mass)
-            k1 = err.div((1, 0), (mdf[i] ** delta_mass, err.pow((mdf[i], smdf[i]), (delta_mass, 0))))
-        else:
-            k0 = 1
-            k1 = 0
+        k0, k1 = _discr(_mdf=mdf[i], _smdf=smdf[i], _m40=m40[i], _m=m[i], _method=method[i])
         r0.append(a0[i] * k0)
         r1.append(err.mul((a0[i], e0[i]), (k0, k1)))
     return [r0, r1]
@@ -261,8 +264,8 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
                   R39v37ca: Tuple[float, float], R36v37ca: Tuple[float, float], R38v37ca: Tuple[float, float],
                   R40v39k: Tuple[float, float], R38v39k: Tuple[float, float],
                   R36v38clp: Tuple[float, float],
-                  L37ar: Tuple[float, float], L39ar: Tuple[float, float], L36cl: Tuple[float, float],
-                  MDFunc: Union[MethodType],
+                  L37ar: Tuple[float, float], L39ar: Tuple[float, float],
+                  L36cl: Tuple[float, float],
                   MDF: Tuple[float, float],
                   M40: Tuple[float, float], M39: Tuple[float, float], M38: Tuple[float, float],
                   M37: Tuple[float, float], M36: Tuple[float, float],
@@ -303,9 +306,19 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     """
     # define parameters
 
-    MDFunc = lambda _M40, _mass, _mdf: 1 / ((_M40 - _mass) * (_mdf - 1) + 1)
-
-    Monte_Carlo_Size = 10000
+    blank_gain_corr = options.get('blank_gain_corr', True)
+    mdf_method = options.get('mdf_method', 'linear')
+    force_to_zero = options.get('force_to_zero', True)
+    Monte_Carlo_Size = options.get('monte_carlo_size', 5000)
+
+    if mdf_method.lower().startswith("l"):  # linear
+        MDFunc = lambda _M40, _mass, _mdf: 1 / ((_M40 - _mass) * (_mdf - 1) + 1)
+    elif mdf_method.lower().startswith("e"):  # exponential
+        MDFunc = lambda _M40, _mass, _mdf: 1 / np.exp((_mdf - 1) * _mass * abs(_M40 / _m))
+    elif mdf_method.lower().startswith("p"):  # power
+        MDFunc = lambda _M40, _mass, _mdf: 1 / (_mdf ** abs(_M40 - _mass))
+    else:
+        raise KeyError(f"Worong MDF method {mdf_method} found. Linear, exponential or power required.")
 
     # generate random
     ar40m = random_normal_absolute(*ar40m, size=Monte_Carlo_Size)
@@ -348,8 +361,6 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
 
     JNFactor = random_normal_absolute(*JNFactor, size=Monte_Carlo_Size)
 
-    blank_gain_corr = options.get('blank_gain_corr', True)
-
     def do_simulation():
         i = 0
         while i < Monte_Carlo_Size:
@@ -364,61 +375,100 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
             _ar40m = ar40m[i]
 
             _ar36 = (ar36m[i] / G36[i] - ar36b[i] / (G36[i] if blank_gain_corr else 1)) * P36Mdf
-            _ar37 = (ar37m[i] / G37[i] - ar37b[i] / (G37[i] if blank_gain_corr else 1)) * P37Mdf
+            _ar37 = (ar37m[i] / G37[i] - ar37b[i] / (G37[i] if blank_gain_corr else 1)) * P37Mdf * P37Decay
             _ar38 = (ar38m[i] / G38[i] - ar38b[i] / (G38[i] if blank_gain_corr else 1)) * P38Mdf
-            _ar39 = (ar39m[i] / G39[i] - ar39b[i] / (G39[i] if blank_gain_corr else 1)) * P39Mdf
+            _ar39 = (ar39m[i] / G39[i] - ar39b[i] / (G39[i] if blank_gain_corr else 1)) * P39Mdf * P39Decay
             _ar40 = (ar40m[i] / G40[i] - ar40b[i] / (G40[i] if blank_gain_corr else 1)) * P40Mdf
 
-            _ar37ca = _ar37 * P37Decay
-            _ar39k = _ar39 * P39Decay - _ar37ca * R39v37ca[i]
-            _ar38res = _ar38 - _ar39k * R38v39k[i] - _ar37ca * R38v37ca[i]
-            _ar36res = _ar36 - _ar37ca * R36v37ca[i]
-            _ar36cl = (_ar36res - _ar38res / R38v36a[i]) / (1 - 1 / (R36v38clp[i] * (1 - exp(-1 * L36cl[i] * stand_time_year)) * R38v36a[i]))
-            _ar36a = _ar36res - _ar36cl
-            _ar40r = _ar40 - _ar36a * R40v36a[i] - _ar39k * R40v39k[i]
-            _ar40ar = _ar40 - _ar39k * R40v39k[i]
-            _ar39k = _ar39k * JNFactor[i]
-            _f = _ar40r / _ar39k
+            if force_to_zero:
+                _ar36 = max(_ar36, 0)
+                _ar37 = max(_ar37, 0)
+                _ar38 = max(_ar38, 0)
+                _ar39 = max(_ar39, 0)
+                _ar40 = max(_ar40, 0)
+
+            _ar37ca = _ar37
+            _ar39ca = _ar37ca * R39v37ca[i]
+            _ar38ca = _ar37ca * R38v37ca[i]
+            _ar36ca = _ar37ca * R36v37ca[i]
+
+            if force_to_zero:
+                _ar39ca = min(_ar39ca, _ar39)
+                _ar38ca = min(_ar38ca, _ar38)
+                _ar36ca = min(_ar36ca, _ar36)
+
+            _ar39k = _ar39 - _ar39ca
+            _ar38k = _ar39k * R38v39k[i]
+            _ar40k = _ar39k * R40v39k[i]
+
+            if force_to_zero:
+                _ar38k = min(_ar38k, _ar38 - _ar38ca)
+                _ar40k = min(_ar40k, _ar40)
+
+            _ar38res = _ar38 - _ar38k - _ar38ca
+            _ar36res = _ar36 - _ar36ca
+
+            if force_to_zero and _ar38res <= 0:
+                _ar36cl = _ar38cl = _ar38a= 0
+                _ar36a = _ar36res
+            else:
+                _ar36cl = (_ar36res - _ar38res / R38v36a[i]) / (
+                            1 - 1 / (R36v38clp[i] * (1 - exp(-1 * L36cl[i] * stand_time_year)) * R38v36a[i]))
+                if force_to_zero:
+                    _ar36cl = min(max(_ar36cl, 0), _ar36res)
+
+                _ar36a = _ar36res - _ar36cl
+                _ar38cl = _ar36cl / (R36v38clp[i] * (1 - exp(-1 * L36cl[i] * stand_time_year)))
+                if force_to_zero:
+                    _ar38cl = min(max(_ar38cl, 0), _ar38res)
+                _ar38a = _ar38res - _ar38cl
+
+            _ar40ar = _ar40 - _ar40k
+            _ar40a = _ar36a * R40v36a[i]
+
+            if force_to_zero:
+                _ar40a = min(_ar40a, _ar40ar)
+
+            _ar40r = _ar40ar - _ar40a
+
+            factor = JNFactor[i]
+
             i += 1
-            # yield _f, _ar36, _ar37, _ar38, _ar39, _ar40, _ar36a, _ar37ca, _ar39k, _ar40r, _ar36cl
-            yield _f, _ar36a, _ar39k, _ar40ar
-
-    simulation = do_simulation()
-    F = []
-    ar36 = []
-    ar37 = []
-    ar38 = []
-    ar39 = []
-    ar40 = []
-
-    ar36a = []
-    ar37ca = []
-    ar39k = []
-    ar40r = []
-    ar36cl = []
-
-    nor_x = []
-    nor_y = []
-    inv_x = []
-    inv_y = []
-    for each in simulation:
-        F.append(each[0])
-        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"{np.mean(F) = }, {np.std(F) = }")
+
+            yield _ar36a, 0, _ar36ca, _ar36cl, _ar37ca, _ar38cl, _ar38a, 0, _ar38k, _ar38ca, _ar39k, _ar39ca, _ar40r, _ar40a, 0, _ar40k, \
+                  (_ar39k * factor) / _ar36a, _ar40ar / _ar36a, \
+                  (_ar39k * factor) / _ar40ar, _ar36a / _ar40ar, \
+                  (_ar39k * factor) / _ar38cl, _ar40r / _ar38cl, \
+                  (_ar39k * factor) / _ar40r, _ar38cl / _ar40r, \
+                  _ar38cl / (_ar39k * factor), _ar40r / (_ar39k * factor), \
+                  _ar36res / _ar40ar, _ar38res / _ar40ar, (_ar39k * factor) / _ar40ar, \
+                  _ar36, _ar37, _ar38, _ar39, _ar40
+
+    data = np.array(list(do_simulation()))
+    means = data.mean(axis=0)
+    stds = data.std(axis=0)
+    phi_nor = np.cov(data[:,16:18].T)[0, 1] / (np.dot(*stds[16:18]))
+    phi_inv = np.cov(data[:,18:20].T)[0, 1] / (np.dot(*stds[18:20]))
+    phi_cl1 = np.cov(data[:,20:22].T)[0, 1] / (np.dot(*stds[20:22]))
+    phi_cl2 = np.cov(data[:,22:24].T)[0, 1] / (np.dot(*stds[22:24]))
+    phi_cl3 = np.cov(data[:,24:26].T)[0, 1] / (np.dot(*stds[24:26]))
+    three_d_cov = np.cov(data[:,26:29].T)
+    phi_3d1 = three_d_cov[0, 1] / (np.dot(*stds[26:28]))
+    phi_3d2 = three_d_cov[0, 2] / (np.dot(*stds[26:29:2]))
+    phi_3d3 = three_d_cov[1, 2] / (np.dot(*stds[27:29]))
+
+    degas_data = np.column_stack((means[0:16], stds[0:16])).ravel()
+    nor_iso = np.append(np.column_stack((means[16:18], stds[16:18])).ravel(), [phi_nor, np.nan])
+    inv_iso = np.append(np.column_stack((means[18:20], stds[18:20])).ravel(), [phi_inv, np.nan])
+    cl1_iso = np.append(np.column_stack((means[20:22], stds[20:22])).ravel(), [phi_cl1, np.nan])
+    cl2_iso = np.append(np.column_stack((means[22:24], stds[22:24])).ravel(), [phi_cl2, np.nan])
+    cl3_iso = np.append(np.column_stack((means[24:26], stds[24:26])).ravel(), [phi_cl3, np.nan])
+    threed_iso = np.append(np.column_stack((means[26:29], stds[26:29])).ravel(), [phi_3d1, phi_3d2, phi_3d3])
+    corrected_data = np.column_stack((means[29:34], stds[29:34])).ravel()
+
+    F = np.append(means[25], stds[25])
+
+    return *F, *degas_data, *nor_iso, *inv_iso, *cl1_iso, *cl2_iso, *cl3_iso, *threed_iso, *corrected_data
 
     # print("F = {0} ± {1}".format(np.mean(F), np.std(F)))
     #
@@ -455,11 +505,7 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     # 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]))
     # 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/plot.py

@@ -53,9 +53,8 @@ def get_axis_scale(data: list, count=6, increment=None, extra_count=0, min_inter
             str(decimal.Decimal(int(interval / mag // min_interval) + min_interval) * decimal.Decimal(str(mag))))
     else:
         increment = decimal.Decimal(increment)
-    start = decimal.Decimal(0)
+    start = decimal.Decimal(_min) // increment * increment
     if _min < 0:
-        start = -increment
         while start > _min:
             start -= increment
     else:

ararpy/calc/raw_funcs.py

@@ -29,6 +29,9 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
     -------
 
     """
+    def power(a0, a1):
+        # return regression.power(a0, a1)
+        raise ValueError("Deprecated regression")
     # if unselected is None:
     #     unselected = []
     # linesData = []
@@ -36,12 +39,12 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
     # un_x = transpose(unselected)[0] if is_twoD(unselected) else []
     reg_handler = [
         regression.linest, regression.quadratic, regression.exponential,
-        regression.power, regression.average]
+        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]
@@ -69,3 +72,39 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
         regCoeffs.append(reg_coeffs)
     return None, linesResults, regCoeffs
 
+
+def get_regression_results(points_data, method):
+    """
+    Parameters
+    ----------
+    points_data : two dimensional list. like [[x1, y1], [x2, y2], ..., [xn, yn]]
+    method :
+
+    Returns
+    -------
+
+    """
+    linesResults, regCoeffs = [], []
+    x, y = transpose(points_data, ignore=False)
+    try:
+        res = method(a0=y, a1=x)
+        line_results = res[0:4]
+        reg_coeffs = res[5]
+        if any(np.isnan(line_results)):
+            raise ValueError
+        if abs(res[0] - min(y)) > 5 * (max(y) - min(y)):
+            raise ValueError
+    except RuntimeError:
+        line_data, line_results, reg_coeffs = [], ['RuntimeError', np.nan, np.nan, np.nan, ], []
+    except np.linalg.LinAlgError:
+        line_data, line_results, reg_coeffs = [], ['MatrixError', np.nan, np.nan, np.nan, ], []
+    except TypeError or IndexError:
+        line_data, line_results, reg_coeffs = [], ['NotEnoughPoints', np.nan, np.nan, np.nan, ], []
+    except ZeroDivisionError:
+        line_data, line_results, reg_coeffs = [], ['ZeroDivisionError', np.nan, np.nan, np.nan, ], []
+    except ValueError:
+        line_data, line_results, reg_coeffs = [], ['BadFitting', np.nan, np.nan, np.nan, ], []
+    except Exception as e:
+        line_data, line_results, reg_coeffs = [], [f'RegressionError: {e}', np.nan, np.nan, np.nan, ], []
+    return None, line_results, reg_coeffs
+