ararpy 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

ararpy/__init__.py

@@ -16,10 +16,10 @@ from . import calc, smp, files, thermo, test
 """ Information """
 
 name = 'ararpy'
-version = '0.0.1.a4'
+version = '0.1.21'
 __version__ = version
 full_version = version
-last_update = '2024-01-04'
+last_update = '2024-03-28'
 
 """ ArArPy Functions """
 
@@ -116,6 +116,8 @@ 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'])
 
+Sample.to_excel = lambda _smp, file_path, *args, **kwargs: smp.export.to_excel(_smp, file_path=file_path, *args, **kwargs)
+
 Sample.show_data = lambda _smp: \
     f"Sample Name: \n\t{_smp.name()}\n" \
     f"Doi: \n\t{_smp.doi()}\n" \

ararpy/calc/age.py

@@ -41,11 +41,13 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     J = arr.array_as_float(kwargs.pop('J'))
     sJ = arr.array_as_float(kwargs.pop('sJ') * J / 100)
     A = arr.array_as_float(kwargs.pop('A'))
-    sA = arr.array_as_float(kwargs.pop('sA') * A / 100)
+    sA = arr.array_as_float(kwargs.pop('sA') * A / 100)  # total A, A = Aec + (Ab+) + (Ab-). Ab- for Ca
     Ae = arr.array_as_float(kwargs.pop('Ae'))
-    sAe = arr.array_as_float(kwargs.pop('sAe') * Ae / 100)
+    sAe = arr.array_as_float(kwargs.pop('sAe') * Ae / 100)  # Aec
     Ab = arr.array_as_float(kwargs.pop('Ab'))
-    sAb = arr.array_as_float(kwargs.pop('sAb') * Ab / 100)
+    sAb = arr.array_as_float(kwargs.pop('sAb') * Ab / 100)  # Ab-
+    Abp = arr.array_as_float(kwargs.pop('Abp'))
+    sAbp = arr.array_as_float(kwargs.pop('sAbp') * Ab / 100)  # Ab+
     W = arr.array_as_float(kwargs.pop('W'))
     sW = arr.array_as_float(kwargs.pop('sW') * W / 100)
     Y = arr.array_as_float(kwargs.pop('Y'))
@@ -61,21 +63,22 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     Lb = arr.array_as_float(kwargs.pop('Lb'))
     sLb = arr.array_as_float(kwargs.pop('sLb') * Lb / 100)
     t = arr.array_as_float(kwargs.pop('t'))
-    st = arr.array_as_float(kwargs.pop('st') * t / 100)
-    # Ap = arr.array_as_float(kwargs.pop('Ap'))
-    # sAp = arr.array_as_float(kwargs.pop('sAp') * Ap / 100)
-    # Kp = arr.array_as_float(kwargs.pop('Kp'))
-    # sKp = arr.array_as_float(kwargs.pop('sKp') * Kp / 100)
+    st = arr.array_as_float(kwargs.pop('st'))
+    Ap = arr.array_as_float(kwargs.pop('Ap'))
+    sAp = arr.array_as_float(kwargs.pop('sAp') * Ap / 100)
+    Kp = arr.array_as_float(kwargs.pop('Kp'))
+    sKp = arr.array_as_float(kwargs.pop('sKp') * Kp / 100)
 
-    # recalculation using Min et al.(2000) equation
+    # calculating using Min et al.(2000) equation
     # lmd = A * W * Y / (f * No)
     V = f * No / ((Ab + Ae) * W * Y)
     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
     t = t * 1000000
     st = st * 1000000
-    # back-calculating Ar40/Ar39 ration for the standard
+    # back-calculating Ar40/Ar39 of the standard
     stdR = (np.exp(t * L) - 1) / J
     # errors of standard age and decay constants were not applied
     sStdR = pow((stdR / J) ** 2 * sJ ** 2, 0.5)
@@ -84,31 +87,27 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     sR_1 = np.sqrt((sF / stdR) ** 2 + (F * sStdR / stdR ** 2) ** 2)  # errors of measured 40Ar/39Ar and J value
     sR_2 = np.sqrt((sF / stdR) ** 2)  # error of measured 40Ar/39Ar only
 
-    BB = 1
-    KK = np.exp(t / V) - 1  # 40Arr / 40K Use standard age
+    useStandardAge = True
+    if useStandardAge:
+        # ln part in Min 2000 equation
+        BB = 1
+        KK = np.exp(t / V) - 1  # 40Arr / 40K Use standard age
+    else:  # use Ar40* and K concentrations of primary standard
+        # not fanished, this function is wrong
+        BB = (Ab + Ae) / Ae
+        KK = Ap / Kp / f
+        raise TypeError(f"Not use standard age. Not supported.")
+
     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  # 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
-    e5 = (-1 * np.log(XX) * V / W - V * BB * KK * R / (W * XX)) ** 2 * sW ** 2  # sW
-    e6 = (np.log(XX) * V / Y) ** 2 * sY ** 2  # sY
-    e7 = (V * BB * KK / XX) ** 2 * sR_1 ** 2  # sR
-    # e8 = (V * BB * KK * R / (Ap * XX)) ** 2 * sAp ** 2  # sAp
-    # e9 = (V * BB * KK * R / (Kp * XX)) ** 2 * sKp ** 2  # sKp
-    e8, e9 = 0, 0
-    # useDecayConst = False
-    # if useDecayConst:  # k0 = log(L / Le * KK * R + 1) / L
-    #     e1 = (V * BB * KK * R / (f * XX)) ** 2 * sf ** 2
-    #     e2 = 0
-    #     e3 = (-1 * np.log(XX) * V / L + BB * KK * R / (L * XX)) ** 2 * sLb ** 2
-    #     e4 = (-1 * np.log(XX) * V / L - Lb * KK * R / (Le ** 2 * XX)) ** 2 * sLe ** 2
-    #     e5 = (V * BB * KK * R / (W * XX)) ** 2 * sW ** 2
-    #     e6 = 0
-    useStandardAge = True
+
     if useStandardAge:
-        e1, e9 = 0, 0
+        # k0 =  V * ln(exp(t/V) - 1 * R + 1)
+        e1 = (np.log(XX) - R * (KK + 1) * t / (V * XX)) ** 2 * sV ** 2  # sV
+        e2 = (BB * (KK + 1) * R / XX) ** 2 * st ** 2  # st
+        e3 = (V * BB * KK / XX) ** 2 * sR_1 ** 2  # sR
+    else:
+        e1, e2, e3 = 0, 0, 0
 
     # change to Ma
     # analytical error, error of 40Ar/39Ar only
@@ -116,7 +115,7 @@ def calc_age_min(F, sF, **kwargs) -> tuple:
     # internal error, errors of 40Ar/39Ar and J value
     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)
+    s3 = np.sqrt(e1 + e2 + e3)
     age = k0
     return age, s1, s2, s3
 
@@ -145,7 +144,7 @@ def calc_age_general(F, sF, J, sJ, L, sL, **kwargs):
     v1 = sF ** 2 * (J / (L * (1 + J * F))) ** 2
     v2 = sJ ** 2 * (F / (L * (1 + J * F))) ** 2
     v3 = sL ** 2 * (np.log(1 + J * F) / (L ** 2)) ** 2
-    s1 = v1 ** .5  # analytical error
-    s2 = (v1 + v2) ** .5  # internal error
-    s3 = (v1 + v2 + v3) ** .5  # full external error
+    s1 = v1 ** .5  # analytical error, F only
+    s2 = (v1 + v2) ** .5  # internal error, F and J
+    s3 = (v1 + v2 + v3) ** .5  # full external error. F, J and L
     return age, s1, s2, s3

ararpy/calc/arr.py

@@ -38,7 +38,7 @@ def mul(*args):
 
     Returns
     -------
-    2D list, [values, errors]
+    two-D list, [values, errors]
     """
     v = np.array(args)
     res = np.zeros([2, v.shape[-1]], dtype=np.float64)
@@ -67,10 +67,11 @@ def div(a, b):
     n = np.shape([a, b])[-1]
     k0, k1 = [], []
     for i in range(n):
-        k0.append(np.divide(a[0][i], b[0][i]))
-        k1.append(
-            (np.divide(a[1][i] ** 2, b[0][i] ** 2) +
-             np.divide(a[0][i] ** 2 * b[1][i] ** 2, b[0][i] ** 4)) ** .5)
+        try:
+            k0.append(np.divide(a[0][i], b[0][i]))
+            k1.append((np.divide(a[1][i] ** 2, b[0][i] ** 2) + np.divide(a[0][i] ** 2 * b[1][i] ** 2, b[0][i] ** 4)) ** .5)
+        except TypeError as e:
+            raise TypeError(f"a = {a[0][i]}, b = {b[0][i]},  {e}")
     return [k0, k1]
 
 
@@ -514,6 +515,15 @@ def transpose(obj, ignore: bool = True):
             raise ValueError
 
 
+def remove_empty(a: list):
+    index = 0
+    for i in range(len(a)):
+        if not is_empty(a[-(i + 1)]):
+            index = len(a) - i
+            break
+    return transpose(a[:index])
+
+
 def get_item(obj: list, loc: (list, tuple, int), default: Union[str, int, float, bool] = None,
              base: Union[int, tuple, list] = 0) -> Union[str, int, float, bool]:
     """ Get item from a n-dimension list
@@ -566,7 +576,7 @@ def wtd_mean(a: list, e: list, sf: int = 1, adjust_error: bool = True):
     k0 = sum(a * wt) / sum(wt)  # error weighting
     k4 = sum((a - k0) ** 2 * wt)  # Chi square
     k3 = k4 / df  # MSWD mentioned in Min et al., 2000
-    if adjust_error:
+    if adjust_error and k3 > 1:
         k1 = (k3 / sum(wt)) ** .5
     else:
         k1 = (1 / sum(wt)) ** .5

ararpy/calc/corr.py

@@ -72,18 +72,18 @@ def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
             v3 = err.div((np.log(ra / rm), v1), (np.log(ratio_m), v2))
             k4 = err.div((np.log(ra / rm) / np.log(ratio_m), v3), (m1, sm1))
         except Exception:
-            k3, k4 = "Null", "Null"
+            k3, k4 = 0, 0
         # pow
         try:
             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:
-            k5, k6 = "Null", "Null"
-        return k1, k2, k3, k4, k5, k6
+            k5, k6 = 0, 0
+        return k1, k2, k2, k2, k3, k4, k4, k4, k5, k6, k6, k6
     else:
         mdf_line_2 = (rm / ra - 1) / delta_m  # Ryu et al., 2013
-        return mdf_line_2, 0, 0, 0, 0, 0
+        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,
@@ -268,7 +268,7 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
                   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,
+                  stand_time_year: float, JNFactor: Tuple[float, float],
                   **options):
     """
 
@@ -294,6 +294,7 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
     L36cl
     MDFunc
     MDF
+    JNFactor
     options
 
     Returns
@@ -307,9 +308,7 @@ 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)
@@ -347,6 +346,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)
 
+    JNFactor = random_normal_absolute(*JNFactor, size=Monte_Carlo_Size)
+
     blank_gain_corr = options.get('blank_gain_corr', True)
 
     def do_simulation():
@@ -376,6 +377,7 @@ def Monte_Carlo_F(ar40m: Tuple[float, float], ar39m: Tuple[float, float], ar38m:
             _ar36a = _ar36res - _ar36cl
             _ar40r = _ar40 - _ar36a * R40v36a[i] - _ar39k * R40v39k[i]
             _ar40ar = _ar40 - _ar39k * R40v39k[i]
+            _ar39k = _ar39k * JNFactor[i]
             _f = _ar40r / _ar39k
             i += 1
             # yield _f, _ar36, _ar37, _ar38, _ar39, _ar40, _ar36a, _ar37ca, _ar39k, _ar40r, _ar36cl

ararpy/calc/jvalue.py

@@ -36,4 +36,4 @@ def j_value(age, sage, r, sr, f, rsf):
     v2 = sage ** 2 * (f * np.exp(f * age) / r) ** 2
     v3 = sr ** 2 * ((1 - np.exp(f * age)) / r ** 2) ** 2
     k1 = np.sqrt(v1 + v2 + v3)
-    return k0, k1
+    return k0, k1, k1, k1

ararpy/calc/plot.py

@@ -39,8 +39,11 @@ def get_axis_scale(data: list, count=6, increment=None, extra_count=0, min_inter
     """
     if len(data) == 0:
         return 0, 1, 5, 0.2  # Default return
-    _max = float(np.ma.masked_invalid(data).max())
-    _min = float(np.ma.masked_invalid(data).min())
+    _max = np.ma.masked_invalid(data).max()
+    _min = np.ma.masked_invalid(data).min()
+    if isinstance(_max, np.ma.core.MaskedConstant) or isinstance(_min, np.ma.core.MaskedConstant):
+        return 0, 1, 5, 0.2  # Default return
+    _max = float(_max); _min = float(_min)
     interval = (_max - _min) / count
     if interval == 0:
         interval = 10

ararpy/files/calc_file.py

@@ -49,8 +49,7 @@ def read_calc_file(file_path: str):
             book_contents[each_sheet] = sheet_contents
         os.remove(decrypt_file_path)
     except Exception as e:
-        print(traceback.format_exc())
-        return False
+        raise
     else:
         return book_contents
 
@@ -420,7 +419,7 @@ def open_full_xls(file_path: str, sample_name: str = ''):
     try:
         res = xls.open_xls(file_path)
     except (Exception, BaseException) as e:
-        return e
+        raise 
     start_row = 5
     rows_num = len(res['Sample Parameters']) - 5
 
@@ -583,8 +582,6 @@ class ArArCalcFile:
 
     def open(self):
         book_contents = read_calc_file(self.file_path)
-        if not book_contents:
-            raise ValueError('Fail to open the file')
         # create data frames for book values
         content = pd.DataFrame(book_contents['Data Tables'])
         logs01 = pd.DataFrame(book_contents['Logs01'])

ararpy/files/raw_file.py

@@ -274,7 +274,7 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 raise ValueError(f"Step name not found")
         except (TypeError, ValueError, IndexError):
             # When parsing the step name fails, the end of the file has been reached
-            break
+            raise
 
         # other information
         options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
@@ -345,10 +345,9 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 break
 
         step_list.append(current_step)
-        step_index += 1
-        idx = input_filter[32] * step_index
+        idx = input_filter[32] * len(step_list)
 
-        if not check_box_index[0] or step_index >= 500:  # check_box_index[0]: multiple sequences
+        if not check_box_index[0] or len(step_list) >= 500:  # check_box_index[0]: multiple sequences
             break
 
     return step_list

ararpy/files/xls.py

@@ -20,8 +20,7 @@ def open_xls(filepath: str):
             sheet = wb.sheet_by_name(sheet_name)
             res[sheet_name] = [[sheet.cell(row, col).value for col in range(sheet.ncols)] for row in range(sheet.nrows)]
     except biffh.XLRDError as e:
-        print('Error in opening excel file: %s' % str(e))
-        return e
+        raise
     else:
         return res
 

ararpy/smp/basic.py

@@ -44,39 +44,97 @@ def calc_apparent_ages(smp: Sample):
     -------
 
     """
-    if smp.Info.sample.type == "Unknown":
-        age = calc_age(smp=smp)
-        smp.ApparentAgeValues[2:6] = age
-        smp.PublishValues[5:7] = copy.deepcopy(age[0:2])
-    if smp.Info.sample.type == "Standard":
-        j = calc_j(smp=smp)
-        smp.ApparentAgeValues[2:4] = j
-        smp.PublishValues[5:7] = copy.deepcopy(j[0:2])
-    if smp.Info.sample.type == "Air":
-        mdf = calc_mdf(smp=smp)
-        smp.ApparentAgeValues[2:4] = mdf
-        smp.PublishValues[5:7] = copy.deepcopy(mdf[0:2])
+    if str(smp.Info.sample.type).lower() == "unknown":
+        v = calc_age(smp=smp)
+    elif str(smp.Info.sample.type).lower() == "standard":
+        v = calc_j(smp=smp)
+    elif str(smp.Info.sample.type).lower() == "air":
+        v = calc_mdf(smp=smp)
+    else:
+        raise TypeError(f"Sample type is not supported: {smp.Info.sample.type}")
+    try:
+        smp.ApparentAgeValues[2:6] = v[0:4]
+        smp.PublishValues[5:7] = copy.deepcopy(v[0:2])
+    except (Exception, BaseException):
+        raise
 
 
 def calc_j(ar40ar39=None, params: dict = None, smp: Sample = None, index: list = None):
-    std_age, std_err = smp.TotalParam[59:61]
-    r, sr = smp.ApparentAgeValues[0:2]  # ar40ar39, error
-    f, rsf = smp.TotalParam[34:36]  # L, sL
-    j, sj = calc.jvalue.j_value(std_age, std_err, r, sr, f, rsf)
-    return [j.tolist(), sj.tolist()]
+    params_index_dict = {
+        34: 'L', 35: 'rsL', 59: 'Age', 60: 'sAge'
+    }
+    if ar40ar39 is None and smp is not None:
+        ar40ar39 = smp.ApparentAgeValues[0:2]  # ar40ar39 air, error
+    if len(np.shape(ar40ar39)) == 1:
+        ar40ar39 = np.reshape(ar40ar39, (2, 1))
+    if index is None:
+        index = list(range(np.shape(ar40ar39)[-1]))
+    if smp is None and params is None:
+        raise ValueError(f"Parameters are required for calculating mdf, or it is empty.")
+    if params is not None:
+        for key, val in params.items():
+            if not isinstance(val, list):
+                params[key] = list(val)
+    if smp is not None:
+        try:
+            params_from_smp = dict(zip(
+                list(params_index_dict.values()),
+                [[smp.TotalParam[i][j] for j in index] for i in params_index_dict.keys()]
+            ))
+        except Exception:
+            print(traceback.format_exc())
+            raise ValueError(f"Parameters cannot be found in the given sample object")
+        if params is not None:
+            params_from_smp.update(params)
+        params = params_from_smp
+
+    j = calc.jvalue.j_value(params['Age'], params['sAge'], *ar40ar39, params['L'], params['rsL'])
+
+    if len(index) == 1:
+        return np.array(j).squeeze().tolist()
+    else:
+        return np.array(j).tolist()
 
 
 def calc_mdf(ar40ar36=None, params: dict = None, smp: Sample = None, index: list = None):
-    std_air, std_err = smp.TotalParam[93:95]
-    m36, sm36 = smp.TotalParam[71:73]
-    m40, sm40 = smp.TotalParam[79:81]
-    air, sair = smp.ApparentAgeValues[0:2]  # ar40ar36 air, error
-    discrimination_method = smp.TotalParam[100]  # L, sL
+    params_index_dict = {
+        71: 'M36', 72: 'sM36', 79: 'M40', 80: 'sM40', 93: 'Air', 94: 'rsAir', 100: 'Discr'
+    }
+    if ar40ar36 is None and smp is not None:
+        ar40ar36 = smp.ApparentAgeValues[0:2]  # ar40ar36 air, error
+    if len(np.shape(ar40ar36)) == 1:
+        ar40ar36 = np.reshape(ar40ar36, (2, 1))
+    if index is None:
+        index = list(range(np.shape(ar40ar36)[-1]))
+    if smp is None and params is None:
+        raise ValueError(f"Parameters are required for calculating mdf, or it is empty.")
+    if params is not None:
+        for key, val in params.items():
+            if not isinstance(val, list):
+                params[key] = list(val)
+    if smp is not None:
+        try:
+            params_from_smp = dict(zip(
+                list(params_index_dict.values()),
+                [[smp.TotalParam[i][j] for j in index] for i in params_index_dict.keys()]
+            ))
+        except Exception:
+            print(traceback.format_exc())
+            raise ValueError(f"Parameters cannot be found in the given sample object")
+        if params is not None:
+            params_from_smp.update(params)
+        params = params_from_smp
+
     mdf = []
-    for i in range(len(std_air)):
-        k = calc.corr.mdf(air[i], sair[i], m36[i], m40[i], std_air[i], std_err[i])  # linear, exp, pow
-        mdf.append({"linear": k[0:2], "exp": k[2:4], "pow": k[4:6]}[discrimination_method[i].lower()])
-    return np.transpose(mdf).tolist()
+    for i in range(len(index)):
+        k = calc.corr.mdf(ar40ar36[0][i], ar40ar36[1][i], params['M36'][i], params['M40'][i],
+                          params['Air'][i], params['rsAir'][i])  # linear, exp, pow
+        mdf.append({"linear": k[0:4], "exp": k[4:8], "pow": k[8:12]}[params['Discr'][i].lower()])
+
+    if len(index) == 1:
+        return np.transpose(mdf).squeeze().tolist()
+    else:
+        return np.transpose(mdf).tolist()
 
 
 def calc_age(ar40ar39=None, params: dict = None, smp: Sample = None, index: list = None):
@@ -95,7 +153,8 @@ def calc_age(ar40ar39=None, params: dict = None, smp: Sample = None, index: list
     """
     params_index_dict = {
         34: 'L', 35: 'sL', 36: 'Le', 37: 'sLe', 38: 'Lb', 39: 'sLb', 48: 'A', 49: 'sA',
-        50: 'Ae', 51: 'sAe', 52: 'Ab', 53: 'sAb', 59: 't', 60: 'st', 67: 'J', 68: 'sJ',
+        50: 'Ae', 51: 'sAe', 52: 'Ab', 53: 'sAb', 54: 'Abp', 55: 'sAbp', 59: 't', 60: 'st',
+        61: 'Ap', 62: 'sAp', 63: 'Kp', 64: 'sKp', 67: 'J', 68: 'sJ',
         81: 'W', 82: 'sW', 83: 'No', 84: 'sNo', 85: 'Y', 86: 'sY', 87: 'f', 88: 'sf', 110: 'Min'
     }
 
@@ -477,7 +536,7 @@ def get_diff_smp(backup: (dict, Sample), smp: (dict, Sample)):
 # =======================
 # Set parameters
 # =======================
-def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None):
+def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None, rows: Optional[List] =None):
     """
     Parameters
     ----------
@@ -485,84 +544,76 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
     params
     flag : optional, should be one of 'calc', 'irra', and 'smp'. If it is not given,
         the text of the extension without a dot will be used
+    rows
 
     Returns
     -------
 
     """
+    if rows is None:
+        rows = []
+    rows = list(set(rows))
+
     if isinstance(params, str) and os.path.isfile(params):
         if flag is None:
             flag = params.split(".")[-1]
         return set_params(smp, read_params(params), flag=flag)
 
-    def remove_none(old_params, new_params, rows, length):
-        res = [[] for _ in range(length)]
+    def isValid(item):
+        valid = True
+        if isinstance(item, (float, int)):
+            valid = not np.isnan(item)
+        return valid and item is not None and item != ""
+
+    def remove_none(old_params, new_params, row_list, length):
+        res = [[old_params[i][j] if j < len(old_params[i]) else None for j in range(max(len(old_params[i]), length))] for i in range(len(old_params))]
         for index, item in enumerate(new_params):
-            if item is None:
-                res[index] = old_params[index]
-            else:
-                res[index] = [item] * rows
+            if isValid(item):
+                for row in row_list:
+                    res[index][row] = item
         return res
 
     n = len(smp.SequenceName)
-
     if n == 0:
-        raise ValueError(f"The number of sample sequences is undefined.")
+        raise ValueError(f"The number of sample sequences is zero")
 
     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)
+        smp.TotalParam[34:56] = remove_none(smp.TotalParam[34:56], params[0:22], rows, n)
+        smp.TotalParam[71:97] = remove_none(smp.TotalParam[71:97], params[22:48], rows, n)
     elif flag == 'irra':
-        smp.TotalParam[0:20] = remove_none(smp.TotalParam[0:20], params[0:20], n, 20 - 0)
-        smp.TotalParam[56:58] = remove_none(smp.TotalParam[56:58], params[20:22], n, 57 - 55)  # Cl36/38 productivity
-        smp.TotalParam[20:27] = remove_none(smp.TotalParam[20:27], params[22:29], n, 27 - 20)
-        # smp.TotalParam[26] = [params[26]] * n
+        smp.TotalParam[0:20] = remove_none(smp.TotalParam[0:20], params[0:20], rows, n)
+        smp.TotalParam[56:58] = remove_none(smp.TotalParam[56:58], params[20:22], rows, n)  # Cl36/38 productivity
+        smp.TotalParam[20:27] = remove_none(smp.TotalParam[20:27], params[22:29], rows, n)
         irradiation_time = []
         duration = []
         if None not in params[29:-3] and '' not in params[29:-3]:
             for i in range(len(params[29:-3])):
                 if i % 2 == 0:
-                    # [d, t] = params[29:-3][i].split('T')
-                    # [t1, t2] = t.split(':')
-                    # irradiation_time.append(d + '-' + t1 + '-' + t2 + 'D' + str(params[29:-3][i + 1]))
-                    text = params[29:-3][i]
-                    for char in ['T', ':']:
-                        text = text.replace(char, '-')
                     irradiation_time.append(params[29:-3][i] + 'D' + str(params[29:-3][i + 1]))
                     duration.append(float(params[29:-3][i + 1]))
-            smp.TotalParam[27] = ['S'.join(irradiation_time)] * n
-            smp.TotalParam[28] = [params[-3]] * n
-            smp.TotalParam[29] = [sum(duration)] * n
+            smp.TotalParam[27:30] = remove_none(smp.TotalParam[27:30], ['S'.join(irradiation_time), params[-3], sum(duration)], rows, n)
         if params[-5] != '':
-            # [a, b] = params[-5].split('T')
-            # [b, c] = b.split(':')
-            # smp.TotalParam[30] = [a + '-' + b + '-' + c] * n
-            text = params[-5]
-            for char in ['T', ':']:
-                text = text.replace(char, '-')
-            # smp.TotalParam[30] = [text] * n
-            smp.TotalParam[30] = [params[-5]] * n
+            smp.TotalParam[30:32] = remove_none(smp.TotalParam[30:32], [params[-5], None], rows, n)
         try:
             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)]
+                    *re.findall(r"\d+", smp.TotalParam[30][i])) for i in range(len(smp.TotalParam[30]))]
         except (BaseException, Exception):
             print(f'Error in calculate standing duration: {traceback.format_exc()}')
-            raise
+            smp.TotalParam[32] = [None for index in range(n)]
         else:
-            smp.TotalParam[32] = [i / (3600 * 24 * 365.242) for i in stand_time_second]  # stand year
+            smp.TotalParam[32] = [item / (3600 * 24 * 365.242) if index in rows else smp.TotalParam[32][index] for index, item in enumerate(stand_time_second)]  # stand year
 
     elif flag == 'smp':
-        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[67:71] = remove_none(smp.TotalParam[67:71], params[0:4], rows, n)
+        smp.TotalParam[58:67] = remove_none(smp.TotalParam[58:67], params[4:13], rows, n)
+        smp.TotalParam[97:100] = remove_none(smp.TotalParam[97:100], params[13:16], rows, n)
+        smp.TotalParam[115:120] = remove_none(smp.TotalParam[115:120], params[16:21], rows, n)
+        smp.TotalParam[126:136] = remove_none(smp.TotalParam[126:136], params[21:31], rows, n)
+        # smp.TotalParam[120:123] = remove_none(smp.TotalParam[120:123], params[31:34], rows, n)
         smp.TotalParam[100:114] = remove_none(
             smp.TotalParam[100:114],
-            [['Linear', 'Exponential', 'Power'][params[35:38].index(True)] if True in params[35:38] else '', *params[38:]], n, 114 - 100)
+            [['Linear', 'Exponential', 'Power'][params[35:38].index(True)] if True in params[35:38] else '', *params[38:]], rows, n)
         pref = dict(zip(preference_keys, params[31:35]))
         smp.Info.preference.update(pref)
         for key, comp in get_components(smp).items():
@@ -570,7 +621,6 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
                 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, "