ararpy 0.1.14__py3-none-any.whl → 0.1.17__py3-none-any.whl

ararpy/__init__.py

@@ -10,7 +10,7 @@
 """
 
 import pandas as pd
-from . import calc, smp, files, test
+from . import calc, smp, files, thermo, test
 
 
 """ Information """

ararpy/calc/age.py

@@ -20,6 +20,7 @@ import numpy as np
 def calc_age_min(F, sF, **kwargs) -> tuple:
     """
     Calculate ArAr ages using Min et al. (2000) equation.
+    Note that the Ar/K of primary standards is not working currently
     Parameters
     ----------
     F : array-like
@@ -33,6 +34,7 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
 
     Returns
     -------
+    [age, s1, s2, s3] in years
 
     """
     F, sF = arr.array_as_float([F, sF]).astype(float)
@@ -68,7 +70,6 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     # recalculation using Min et al.(2000) equation
     # lmd = A * W * Y / (f * No)
     V = f * No / ((Ab + Ae) * W * Y)
-    sf = 0  # the error of f was not considered by Koppers
     sV = pow((V / f * sf) ** 2 + (V / No * sNo) ** 2 + (V / (Ab + Ae)) ** 2 * (sAb ** 2 + sAe ** 2) +
              (V / W * sW) ** 2 + (V / Y * sY) ** 2, 0.5)
     # standard age in year, change to Ma
@@ -87,7 +88,7 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     KK = np.exp(t / V) - 1  # 40Arr / 40K Use standard age
     XX = BB * KK * R + 1
     k0 = V * np.log(XX)
-    e1 = (np.log(XX) * V / f - V * BB * KK * R / (f * XX)) ** 2 * sf ** 2  # sFr
+    e1 = (np.log(XX) * V / f - V * BB * KK * R / (f * XX)) ** 2 * sf ** 2  # sF
     e2 = (np.log(XX) * V / No) ** 2 * sNo ** 2  # sNo
     e3 = (-1 * np.log(XX) * V / A + BB * KK * R / (A * XX)) ** 2 * sAb ** 2  # sAb
     e4 = (-1 * np.log(XX) * V / A - Ab * KK * R / (Ae ** 2 * XX)) ** 2 * sAe ** 2  # sAe
@@ -111,12 +112,12 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
 
     # change to Ma
     # analytical error, error of 40Ar/39Ar only
-    s1 = np.sqrt((V * KK * BB / XX) ** 2 * sR_2 ** 2) / 1000000
+    s1 = np.sqrt((V * KK * BB / XX) ** 2 * sR_2 ** 2)
     # internal error, errors of 40Ar/39Ar and J value
-    s2 = np.sqrt((V * KK * BB / XX) ** 2 * sR_1 ** 2) / 1000000
+    s2 = np.sqrt((V * KK * BB / XX) ** 2 * sR_1 ** 2)
     # total external error
-    s3 = np.sqrt(e1 + e2 + e3 + e4 + e5 + e6 + e7 + e8 + e9) / 1000000
-    age = k0 / 1000000
+    s3 = np.sqrt(e1 + e2 + e3 + e4 + e5 + e6 + e7 + e8 + e9)
+    age = k0
     return age, s1, s2, s3
 
 
@@ -135,7 +136,7 @@ def calc_age_general(F, sF, J, sJ, L, sL, **kwargs):
 
     Returns
     -------
-    tuple of array objects, (age, s1, s2, s3)
+    tuple of array objects, (age, s1, s2, s3), in years
     """
     F, sF, J, sJ, L, sL = np.array([F, sF, J, sJ, L, sL])
     sJ = sJ * J / 100
@@ -147,4 +148,4 @@ def calc_age_general(F, sF, J, sJ, L, sL, **kwargs):
     s1 = v1 ** .5  # analytical error
     s2 = (v1 + v2) ** .5  # internal error
     s3 = (v1 + v2 + v3) ** .5  # full external error
-    return age / 1000000, s1 / 1000000, s2 / 1000000, s3 / 1000000
+    return age, s1, s2, s3

ararpy/calc/basic.py

@@ -12,6 +12,8 @@
 import copy
 import random
 import string
+import numpy as np
+from scipy import stats
 from datetime import datetime, timezone, timedelta
 import pytz
 
@@ -66,7 +68,7 @@ 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():
+        if key not in res.keys() and str(key).isnumeric():
             key = int(key)
         if key not in res.keys():
             res[key] = val
@@ -100,3 +102,30 @@ def update_dicts(a: dict, b: dict):
 
 def get_random_digits(length: int = 7) -> str:
     return ''.join(random.choices(string.digits, k=length))
+
+
+def monte_carlo(func, inputs, confidence_level, **kwargs):
+    """
+
+    Parameters
+    ----------
+    func: Callable
+    inputs: array
+        two-dimensional array
+    confidence_level: float
+        [0, 1]
+
+    Returns
+    -------
+
+    """
+    N = len(inputs)
+    l_range = int(0.5 * (1 - confidence_level) * N)
+    r_range = N - l_range - 1
+    values = np.transpose([func(*each, **kwargs) for each in inputs])
+    cov = np.cov(values, rowvar=True)
+    values = np.sort(values, axis=1)  # sort to find the lower and upper limitation at the given confidence level
+    means = np.mean(values, axis=1).reshape(len(values), 1)
+    limits = values[:, [l_range, r_range]]
+
+    return np.concatenate((means, limits), axis=1), cov

ararpy/calc/corr.py

@@ -59,14 +59,14 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
     sdelta_m = err.add(sm2, sm1)
     ratio_m = m2 / m1
     sratio_m = err.div((m2, sm2), (m1, sm1))
-    isAapkop = True
-    if isAapkop:
+    useRyu = False
+    if not useRyu:
         # line
-        k1 = (ra / rm + delta_m - 1) / delta_m  # A.A.P.Koppers
+        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
         try:
-            k3 = (np.log(ra / rm) / np.log(ratio_m)) * (1 / m1) + 1  # A.A.P.Koppers
+            k3 = (np.log(ra / rm) / np.log(ratio_m)) * (1 / m1) + 1
             v1 = err.log((ra / rm, err.div((ra, sra), (rm, srm))))
             v2 = err.log((ratio_m, sratio_m))
             v3 = err.div((np.log(ra / rm), v1), (np.log(ratio_m), v2))
@@ -75,7 +75,7 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
             k3, k4 = "Null", "Null"
         # pow
         try:
-            k5 = pow((ra / rm), (1 / delta_m))  # A.A.P.Koppers, also Renne2009, B.D. Turrin2010
+            k5 = pow((ra / rm), (1 / delta_m))  # Renne2009, B.D. Turrin2010
             k6 = err.pow((ra / rm, err.div((ra, sra), (rm, srm))),
                          (1 / delta_m, err.div((1, 0), (delta_m, sdelta_m))))
         except Exception:
@@ -247,6 +247,8 @@ def random_normal_relative(mu, std, size):
 
 
 def random_normal_absolute(mu, std, size):
+    if np.isnan(std):
+        std = 0
     return np.random.normal(mu, std, size)
 
 
@@ -262,13 +264,12 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
                   L37ar: Tuple[float, float], L39ar: Tuple[float, float], L36cl: Tuple[float, float],
                   MDFunc: Union[MethodType],
                   MDF: Tuple[float, float],
-                  M40: Tuple[float, float],
-                  M39: Tuple[float, float],
-                  M38: Tuple[float, float],
-                  M37: Tuple[float, float],
-                  M36: Tuple[float, float],
+                  M40: Tuple[float, float], M39: Tuple[float, float], M38: Tuple[float, float],
+                  M37: Tuple[float, float], M36: Tuple[float, float],
+                  G40: Tuple[float, float], G39: Tuple[float, float], G38: Tuple[float, float],
+                  G37: Tuple[float, float], G36: Tuple[float, float],
                   stand_time_year: float,
-                  **options) -> Tuple[float, float]:
+                  **options):
     """
 
     Parameters
@@ -306,7 +307,9 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     Monte_Carlo_Size = 10000
 
     # generate random
+    print(ar40m)
     ar40m = random_normal_absolute(*ar40m, size=Monte_Carlo_Size)
+    print(ar40m)
     ar39m = random_normal_absolute(*ar39m, size=Monte_Carlo_Size)
     ar38m = random_normal_absolute(*ar38m, size=Monte_Carlo_Size)
     ar37m = random_normal_absolute(*ar37m, size=Monte_Carlo_Size)
@@ -325,6 +328,12 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     M37 = random_normal_relative(*M37, size=Monte_Carlo_Size)
     M36 = random_normal_relative(*M36, size=Monte_Carlo_Size)
 
+    G40 = random_normal_relative(*G40, size=Monte_Carlo_Size)
+    G39 = random_normal_relative(*G39, size=Monte_Carlo_Size)
+    G38 = random_normal_relative(*G38, size=Monte_Carlo_Size)
+    G37 = random_normal_relative(*G37, size=Monte_Carlo_Size)
+    G36 = random_normal_relative(*G36, size=Monte_Carlo_Size)
+
     L36cl = random_normal_relative(*L36cl, size=Monte_Carlo_Size)
     L37ar = random_normal_relative(*L37ar, size=Monte_Carlo_Size)
     L39ar = random_normal_relative(*L39ar, size=Monte_Carlo_Size)
@@ -338,6 +347,8 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     R38v39k = random_normal_relative(*R38v39k, size=Monte_Carlo_Size)
     R36v38clp = random_normal_relative(*R36v38clp, size=Monte_Carlo_Size)
 
+    blank_gain_corr = options.get('blank_gain_corr', True)
+
     def do_simulation():
         i = 0
         while i < Monte_Carlo_Size:
@@ -351,20 +362,20 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
 
             _ar40m = ar40m[i]
 
-            _ar36 = (ar36m[i] - ar36b[i]) * P36Mdf
-            _ar37 = (ar37m[i] - ar37b[i]) * P37Mdf
-            _ar38 = (ar38m[i] - ar38b[i]) * P38Mdf
-            _ar39 = (ar39m[i] - ar39b[i]) * P39Mdf
-            _ar40 = (ar40m[i] - ar40b[i]) * P40Mdf
+            _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
+            _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
+            _ar40 = (ar40m[i] / G40[i] - ar40b[i] / (G40[i] if blank_gain_corr else 1)) * P40Mdf
 
-            _ar37ca = (ar37m[i] - ar37b[i]) * P37Mdf * P37Decay
-            _ar39k = (ar39m[i] - ar39b[i]) * P39Mdf * P39Decay - _ar37ca * R39v37ca[i]
-            _ar38res = (ar38m[i] - ar38b[i]) * P38Mdf - _ar39k * R38v39k[i] - _ar37ca * R38v37ca[i]
-            _ar36res = (ar36m[i] - ar36b[i]) * P36Mdf - _ar37ca * R36v37ca[i]
+            _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 = (ar40m[i] - ar40b[i]) * P40Mdf - _ar36a * R40v36a[i] - _ar39k * R40v39k[i]
-            _ar40ar = (ar40m[i] - ar40b[i]) * P40Mdf - _ar39k * R40v39k[i]
+            _ar40r = _ar40 - _ar36a * R40v36a[i] - _ar39k * R40v39k[i]
+            _ar40ar = _ar40 - _ar39k * R40v39k[i]
             _f = _ar40r / _ar39k
             i += 1
             # yield _f, _ar36, _ar37, _ar38, _ar39, _ar40, _ar36a, _ar37ca, _ar39k, _ar40r, _ar36cl
@@ -405,6 +416,8 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
         # ar40r.append(each[9])
         # ar36cl.append(each[10])
 
+    print(f"{np.mean(F) = }, {np.std(F) = }")
+
     # print("F = {0} ± {1}".format(np.mean(F), np.std(F)))
     #
     # with open("ar36m.txt", 'w') as f:  # save serialized json data to a readable text

ararpy/calc/regression.py

@@ -42,8 +42,8 @@ def york2(x: list, sx: list, y: list, sy: list, ri: list, f: int = 1,
     Returns
     -------
     Intercept | Error | slope | Error | MSWD | Convergence | Number of Iterations | error magnification | other
-     b, sb, a, sa, mswd, dF, Di, k, r2, chi_square, p_value
-    b, seb, m, sem, mswd, abs(m - last_m), Di, k, r2, chi_square, p_value, avg_err_s
+    b, sb, a, sa, mswd, dF, Di, k, r2, chi_square, p_value, avg_err_s, cov_b_m
+    b, seb, m, sem, mswd, abs(m - last_m), Di, k, r2, chi_square, p_value, avg_err_s, cov_b_m
     """
     data = np.array([x, sx, y, sy, ri])
     data = data[:, np.where(
@@ -110,6 +110,7 @@ def york2(x: list, sx: list, y: list, sy: list, ri: list, f: int = 1,
     r2 = ssreg / sstotal if sstotal != 0 else np.inf  # r2 = ssreg / sstotal
     chi_square = mswd * (n - 2)
     p_value = distributions.chi2.sf(chi_square, n - 2)
+    cov_b_m = - np.mean(X) * (ssresid / (n - 2) / np.sum((X - np.mean(X)) ** 2))  # covariance of intercept b and slope m
     # 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))
     avg_err_s = sum(err_s(m, b)) / len(x) * 100
@@ -127,7 +128,7 @@ def york2(x: list, sx: list, y: list, sy: list, ri: list, f: int = 1,
     #     k, sk, m, sm, mswd, conv, iter, mag, r2, chisq, p, avg_err
     # ]
 
-    return b, seb, m, sem, mswd, abs(m - last_m), Di, k, r2, chi_square, p_value, avg_err_s
+    return b, seb, m, sem, mswd, abs(m - last_m), Di, k, r2, chi_square, p_value, avg_err_s, cov_b_m
 
 
 def york2_df(data: pd.DataFrame, f: int = 1, convergence: float = 0.001,

ararpy/files/calc_file.py

@@ -109,6 +109,8 @@ def open_252(data: pd.DataFrame, logs01: pd.DataFrame, logs02: pd.DataFrame):
         -999, -999, -999, -999, -999, -999, -999, -999, -999, -999,  # 100-109
         -999, -999, -999, -999, -1,  # 110-114
         -999, -999, -999, -999, -999, -999, -999, -999,  # 115-122
+        -999, -999, -999, -999, -999, -999, -999, -999,  # 123-130
+        -999, -999, -999, -999, -999,  # 131-135
     ]
 
     # double transpose to remove keys
@@ -126,7 +128,7 @@ def open_252(data: pd.DataFrame, logs01: pd.DataFrame, logs02: pd.DataFrame):
     sequence = get_data(data, sequence_index)
 
     # adjustment
-    isochron_mark.replace({4.0: 1}, inplace=True)
+    isochron_mark.replace({4.0: '1'}, inplace=True)
     total_param[83] = logs01[1][9]  # No
     total_param[84] = logs01[1][10]  # %SD
     total_param[81] = logs01[1][11]  # K mass
@@ -283,6 +285,10 @@ def open_240(data: pd.DataFrame, logs01: pd.DataFrame, logs02: pd.DataFrame):
         -999, -999, -999, -999, -1,
         # 115-122
         -999, -999, -999, -999, -999, -999, -999, -999,
+        # 123-130
+        -999, -999, -999, -999, -999, -999, -999, -999,
+        # 131-135
+        -999, -999, -999, -999, -999,
     ]
 
     # double transpose to remove keys
@@ -304,7 +310,7 @@ def open_240(data: pd.DataFrame, logs01: pd.DataFrame, logs02: pd.DataFrame):
         total_param.copy(), logs02, get_data(data, [59, 58, 57, 60, 61]), data[63][0]
     )
     # Do adjustment
-    isochron_mark.replace({4.0: 1}, inplace=True)
+    isochron_mark.replace({4.0: '1'}, inplace=True)
     total_param[44] = logs01[1][40]
     total_param[45] = logs01[1][41]
     total_param[42] = logs01[1][38]
@@ -417,9 +423,10 @@ def open_full_xls(file_path: str, sample_name: str = ''):
         return e
     start_row = 5
     rows_num = len(res['Sample Parameters']) - 5
+
     for key, val in res.items():
         res[key] = arr.transpose(val[:start_row + rows_num])
-        # 2倍误差改回1倍
+        # 2 sigma errors to 1 sigma
         for i in range(len(res[key])):
             if res[key][i][2] in ['2s', '%2s', '± 2s']:
                 _temp = []
@@ -442,7 +449,7 @@ def open_full_xls(file_path: str, sample_name: str = ''):
         res['Incremental Heating Summary'][13][start_row: start_row + rows_num] = _temp
         res['Incremental Heating Summary'][13][start_row: start_row + rows_num] = _s
 
-    # degas相对误差改为绝对误差
+    # degas: change relative uncertainties to absolute
     for i in range(len(res['Degassing Patterns'])):
         if res['Degassing Patterns'][i][2] in ['%1s', '%2s']:
             _temp = []
@@ -453,7 +460,7 @@ def open_full_xls(file_path: str, sample_name: str = ''):
                 except TypeError:
                     _temp.append('')
             res['Degassing Patterns'][i][start_row: start_row + rows_num] = _temp
-    rows = list(range(start_row, rows_num))
+    rows = list(range(start_row, start_row + rows_num))
     sequence_name = arr.partial(res['Procedure Blanks'], rows, 1)
     sequence_value = arr.partial(res['Procedure Blanks'], rows, 2)
     blank_values = arr.partial(
@@ -503,15 +510,17 @@ def open_full_xls(file_path: str, sample_name: str = ''):
             -1, -1,  # 56-57
             -1, -1,  # 58-59
             -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 60-68
-            10, 11, 12, 13,  #
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  #
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  #
-            -1, -1, -1, -1,  #
-            -1, -1, -1, -1,  #
-            -1, -1, -1, -1, -1,  #
-            -1, -1, -1, -1,  #
-            -1, -1, -1, -1,  #
-            -1,  #
+            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
         ])
 
     month_convert = {'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',
@@ -544,7 +553,7 @@ def open_full_xls(file_path: str, sample_name: str = ''):
     isochron_values[24:29] = isochron.get_data(
         degas_values[10], degas_values[11], degas_values[24], degas_values[25], degas_values[20], degas_values[21]
     )  # 38/39, 40/39
-    isochron_mark = [1 if i == 'P' else '' for i in arr.partial(
+    isochron_mark = ['1' if i == 'P' else '' for i in arr.partial(
         res['Normal Isochron Table'], rows, 3)]
 
     sample_info = {

ararpy/smp/basic.py

@@ -20,6 +20,7 @@ from typing import Optional, Union, List
 from .. import calc
 from ..files.basic import (read as read_params)
 from .sample import Sample, Table, Plot, ArArData, ArArBasic, Sequence, RawData
+from .initial import preference_keys
 
 Set = Plot.Set
 Label = Plot.Label
@@ -128,20 +129,38 @@ def calc_age(ar40ar39=None, params: dict = None, smp: Sample = None, index: list
             params_from_smp.update(params)
         params = params_from_smp
 
+    u = 'Ma'
+    try:
+        u = smp.Info.preference['ageUnit']
+    except:
+        print(traceback.format_exc())
+        pass
+    finally:
+        if u.lower() == 'ga':
+            age_unit_factor = 1000000000
+        elif u.lower() == 'ma':
+            age_unit_factor = 1000000
+        elif u.lower() == 'ka':
+            age_unit_factor = 1000
+        else:
+            age_unit_factor = 1
+
     # check if using Min equation
     params['Min'] = [i if isinstance(i, bool) else False for i in params['Min']]
 
-    idx1 = np.flatnonzero(np.where(params['Min'], True, False))  # True, using Min euqation
+    idx1 = np.flatnonzero(np.where(params['Min'], True, False))  # True, using Min equation
     idx2 = np.flatnonzero(np.where(params['Min'], False, True))  # False
     k1, k2 = [], []
     if np.size(idx1) > 0:
         k1 = calc.age.calc_age_min(
             F=[ar40ar39[0][i] for i in idx1], sF=[ar40ar39[1][i] for i in idx1],
             **dict(zip(params.keys(), [[val[i] for i in idx1] for val in params.values()])))
+        k1 = [i / age_unit_factor for i in k1]
     if np.size(idx2) > 0:
         k2 = calc.age.calc_age_general(
             F=[ar40ar39[0][i] for i in idx2], sF=[ar40ar39[1][i] for i in idx2],
             **dict(zip(params.keys(), [[val[i] for i in idx2] for val in params.values()])))
+        k2 = [i / age_unit_factor for i in k2]
 
     # idx1 = params[params['Min'].astype(bool)].index
     # idx2 = params[~params['Min'].astype(bool)].index  # The operators are: | for or, & for and, and ~ for not
@@ -477,7 +496,7 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
         return set_params(smp, read_params(params), flag=flag)
 
     def remove_none(old_params, new_params, rows, length):
-        res = [[]] * length
+        res = [[] for _ in range(length)]
         for index, item in enumerate(new_params):
             if item is None:
                 res[index] = old_params[index]
@@ -487,6 +506,9 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
 
     n = len(smp.SequenceName)
 
+    if n == 0:
+        raise ValueError(f"The number of sample sequences is undefined.")
+
     if flag == 'calc':
         smp.TotalParam[34:56] = remove_none(smp.TotalParam[34:56], params[0:22], n, 56 - 34)
         smp.TotalParam[71:97] = remove_none(smp.TotalParam[71:97], params[22:48], n, 97 - 71)
@@ -524,22 +546,32 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
             stand_time_second = [
                 calc.basic.get_datetime(*re.findall(r"\d+", smp.TotalParam[31][i])) - calc.basic.get_datetime(
                     *re.findall(r"\d+", smp.TotalParam[30][i])) for i in range(n)]
-        except TypeError:
+        except (BaseException, Exception):
             print(f'Error in calculate standing duration: {traceback.format_exc()}')
+            raise
         else:
             smp.TotalParam[32] = [i / (3600 * 24 * 365.242) for i in stand_time_second]  # stand year
 
     elif flag == 'smp':
-        print(params)
+        print(dict(zip([i for i in range(len(params))], params)))
         smp.TotalParam[67:71] = remove_none(smp.TotalParam[67:71], params[0:4], n, 71 - 67)
         smp.TotalParam[58:67] = remove_none(smp.TotalParam[58:67], params[4:13], n, 67 - 58)
         smp.TotalParam[97:100] = remove_none(smp.TotalParam[97:100], params[13:16], n, 100 - 97)
         smp.TotalParam[115:120] = remove_none(smp.TotalParam[115:120], params[16:21], n, 120 - 115)
         smp.TotalParam[126:136] = remove_none(smp.TotalParam[126:136], params[21:31], n, 136 - 126)
-        smp.TotalParam[120:123] = remove_none(smp.TotalParam[120:123], params[31:34], n, 123 - 120)
+        # smp.TotalParam[120:123] = remove_none(smp.TotalParam[120:123], params[31:34], n, 123 - 120)
         smp.TotalParam[100:114] = remove_none(
             smp.TotalParam[100:114],
-            [['Linear', 'Exponential', 'Power'][params[34:37].index(True)] if True in params[34:37] else '', *params[37:]], n, 114 - 100)
+            [['Linear', 'Exponential', 'Power'][params[35:38].index(True)] if True in params[35:38] else '', *params[38:]], n, 114 - 100)
+        pref = dict(zip(preference_keys, params[31:35]))
+        smp.Info.preference.update(pref)
+        for key, comp in get_components(smp).items():
+            if isinstance(comp, Table):
+                comp.decimal_places = pref['decimalPlaces']
+                comp.set_coltypes()
+        smp.AgeSpectraPlot.yaxis.title.text = f"Apparent Age ({str(pref['ageUnit']).capitalize()})"
+        print(smp.Info.preference)
+
     else:
         raise KeyError(f"{flag = } is not supported. It must be 'calc' for Calc Params, "
                        f"'irra' for Irradiation Params, or 'smp' for Sample Params.")
@@ -547,16 +579,22 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
 
 
 def get_sequence(smp: Sample):
+    set1_index = [index for index, _ in enumerate(smp.IsochronMark) if _ in [1, '1']]
+    set2_index = [index for index, _ in enumerate(smp.IsochronMark) if _ in [2, '2']]
+    set3_index = list(set(range(0, len(smp.IsochronMark))) - set(set1_index) - set(set2_index))
+    smp.SelectedSequence1 = set1_index
+    smp.SelectedSequence2 = set2_index
+    smp.UnselectedSequence = set3_index
+    smp.Info.results.selection[0]['data'] = smp.SelectedSequence1
+    smp.Info.results.selection[1]['data'] = smp.SelectedSequence2
+    smp.Info.results.selection[2]['data'] = smp.UnselectedSequence
     return ArArBasic(
         size=len(smp.SequenceName), name=smp.SequenceName, value=smp.SequenceValue, unit=smp.SequenceUnit,
         mark=ArArBasic(
             size=len(smp.IsochronMark), value=smp.IsochronMark,
-            set1=ArArBasic(size=sum([1 if i == 1 else 0 for i in smp.IsochronMark]),
-                           index=[index for index, _ in enumerate(smp.IsochronMark) if _ == 1]),
-            set2=ArArBasic(size=sum([1 if i == 2 else 0 for i in smp.IsochronMark]),
-                           index=[index for index, _ in enumerate(smp.IsochronMark) if _ == 2]),
-            unselected=ArArBasic(size=sum([0 if i == 2 or i == 1 else 1 for i in smp.IsochronMark]),
-                                 index=[index for index, _ in enumerate(smp.IsochronMark) if _ != 1 and _ != 2]),
+            set1=ArArBasic(size=len(set1_index), index=set1_index),
+            set2=ArArBasic(size=len(set2_index), index=set2_index),
+            unselected=ArArBasic(size=len(set3_index), index=set3_index),
         )
     )
 

ararpy/smp/corr.py

@@ -506,11 +506,11 @@ def monte_carlo_f(sample: Sample):
     M39 = np.transpose(sample.TotalParam[77:79])
     M40 = np.transpose(sample.TotalParam[79:81])
 
-    # M36 = [[35.96754628, 0] for i in range(sequence_num)]
-    # M37 = [[36.9667759, 0] for i in range(sequence_num)]
-    # M38 = [[37.9627322, 0] for i in range(sequence_num)]
-    # M39 = [[38.964313, 0] for i in range(sequence_num)]
-    # M40 = [[39.962383123, 0] for i in range(sequence_num)]
+    G36 = np.transpose(sample.TotalParam[126:128])  # gain correction factors
+    G37 = np.transpose(sample.TotalParam[128:130])
+    G38 = np.transpose(sample.TotalParam[130:132])
+    G39 = np.transpose(sample.TotalParam[132:134])
+    G40 = np.transpose(sample.TotalParam[134:136])
 
     MDF = np.transpose(sample.TotalParam[69:71])
 
@@ -553,6 +553,7 @@ def monte_carlo_f(sample: Sample):
             ar40m=ar40m[i], ar39m=ar39m[i], ar38m=ar38m[i], ar37m=ar37m[i], ar36m=ar36m[i],
             ar40b=ar40b[i], ar39b=ar39b[i], ar38b=ar38b[i], ar37b=ar37b[i], ar36b=ar36b[i],
             M40=M40[i], M39=M39[i], M38=M38[i], M37=M37[i], M36=M36[i],
+            G40=G40[i], G39=G39[i], G38=G38[i], G37=G37[i], G36=G36[i],
             t1=t1[i], t2=t2[i], t3=t3[i],
             R40v36a=R40v36a[i], R38v36a=R38v36a[i],
             R39v37ca=R39v37ca[i], R36v37ca=R36v37ca[i], R38v37ca=R38v37ca[i],
@@ -560,7 +561,8 @@ def monte_carlo_f(sample: Sample):
             R36v38clp=R36v38clp[i],
             L37ar=L37ar[i], L39ar=L39ar[i], L36cl=L36cl[i],
             MDFunc=None,
-            MDF=MDF[i], stand_time_year=stand_time_year[i]
+            MDF=MDF[i], stand_time_year=stand_time_year[i],
+            blank_gain_corr=sample.TotalParam[111][i]
         )
 
         yield res