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

ararpy/smp/basic.py

@@ -20,7 +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
+from .initial import PREFERENCE_RES
 
 Set = Plot.Set
 Label = Plot.Label
@@ -30,6 +30,62 @@ Text = Plot.Text
 pd.options.mode.chained_assignment = None  # default='warn'
 
 
+# =======================
+# Params validate
+# =======================
+class ParamsInvalid(Exception):
+    """    """
+    def __init__(self, code, message, context=None):
+        self.code = code
+        self.message = message
+        self.context = context or {}
+        # 调用父类构造函数，确保异常能正常抛出
+        super().__init__(f"{self.message}")
+
+
+def validate_params(**kwargs):
+
+    def check(data, dtype, **kwargs):
+        k = np.array(data, dtype=dtype)
+        # if dtype != str:
+        #     if np.isnan(k).any():
+        #         raise ValueError("Array contains NaN value(s)")
+        #     if np.isinf(k).any():
+        #         raise ValueError("Array contains Inf value(s)")
+        if dtype == bool:
+            if not all([isinstance(i, bool) or i in [0, 1] for i in np.array(data).flatten()]):
+                raise  ValueError("array contains non-bool value(s)")
+        elif dtype == int:
+            for each in k.flatten():
+                if isinstance(each, dtype):
+                    raise  ValueError(f"type error, {type(each)} is given")
+        if kwargs.keys().__contains__('func'):
+            for each in k.ravel():
+                try:
+                    if not kwargs.get('func')(each):
+                        raise ValueError
+                except (Exception, BaseException) as e:
+                    raise ValueError(f"{type(e).__name__}: invalid value, {each}")
+
+    context = {'names': [], 'classnames': [], 'messages': []}
+    for index, (name, content) in enumerate(kwargs.items(), 1):
+
+        try:
+            if isinstance(content, dict):
+                check(**content)
+            elif isinstance(content, list):
+                for each in content:
+                    check(**each)
+        except (Exception, BaseException) as e:
+            context['names'].append(name)
+            context['classnames'].append(f"k{index}")
+            context['messages'].append(f"{name} {str(e)}")
+    if not context['names']:
+        return True
+    else:
+        raise ParamsInvalid(400, '. '.join(context['messages']), context)
+
+
 # =======================
 # Calculate ages
 # =======================
@@ -44,39 +100,104 @@ 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])
+    try:
+        params_to_check = {
+            'sample type': {'data': smp.Info.sample.type, 'dtype': str, 'func': lambda x: str(x).lower() in ['unknown', 'standard', 'air'],},
+        }
+    except (IndexError, AttributeError) as e:
+        raise
+    if not validate_params(**params_to_check):
+        return
+
+    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}")
+
+    smp.ApparentAgeValues[2:6] = v[0:4]
+    smp.PublishValues[5:7] = copy.deepcopy(v[0:2])
 
 
 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 +216,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'
     }
 
@@ -131,7 +253,7 @@ def calc_age(ar40ar39=None, params: dict = None, smp: Sample = None, index: list
 
     u = 'Ma'
     try:
-        u = smp.Info.preference['ageUnit']
+        u = smp.Info.preference.age_unit
     except:
         print(traceback.format_exc())
         pass
@@ -369,21 +491,22 @@ def get_merged_smp(a: Sample, b: (Sample, dict)):
                                                         symbol_size = 10, line_type = 'solid'))
     """
 
-    def get_similar_name(_name: str):
+    def get_similar_name(name: str):
         res = []
-        for i in range(len(_name) + 1):
-            str_list = [i for i in _name]
-            str_list.insert(i, '_')
-            res.append(''.join(str_list))
-        for i in range(len(_name)):
-            str_list = [i for i in _name]
-            str_list[i] = str_list[i].capitalize()
-            res.append(''.join(str_list))
-        for i in range(len(_name)):
-            str_list = [i for i in _name]
-            if _name[i] in '-_':
-                str_list.pop(i)
+        for _name in set([name, name.lower(), name.upper()]):
+            for i in range(len(_name) + 1):
+                str_list = [i for i in _name]
+                str_list.insert(i, '_')
                 res.append(''.join(str_list))
+            for i in range(len(_name)):
+                str_list = [i for i in _name]
+                str_list[i] = str_list[i].capitalize()
+                res.append(''.join(str_list))
+            for i in range(len(_name)):
+                str_list = [i for i in _name]
+                if _name[i] in '-_':
+                    str_list.pop(i)
+                    res.append(''.join(str_list))
         return res
 
     if not isinstance(b, dict):
@@ -555,13 +678,13 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
         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:]], rows, n)
-        pref = dict(zip(preference_keys, params[31:35]))
-        smp.Info.preference.update(pref)
+        for index, (key, val) in enumerate(PREFERENCE_RES.items()):
+            setattr(smp.Info.preference, key, type(val)(params[31:35][index]))
         for key, comp in get_components(smp).items():
             if isinstance(comp, Table):
-                comp.decimal_places = pref['decimalPlaces']
+                comp.decimal_places = smp.Info.preference.decimal_places
                 comp.set_coltypes()
-        smp.AgeSpectraPlot.yaxis.title.text = f"Apparent Age ({str(pref['ageUnit']).capitalize()})"
+        smp.AgeSpectraPlot.yaxis.title.text = f"Apparent Age ({str(smp.Info.preference.age_unit).capitalize()})"
 
     else:
         raise KeyError(f"{flag = } is not supported. It must be 'calc' for Calc Params, "
@@ -603,3 +726,36 @@ def get_results(smp: Sample):
             for (key, value) in smp.Info.results.age_plateau.items()))
     )
 
+
+def set_selection(smp: Sample, index: int, mark: int):
+    """
+    Parameters
+    ----------
+    smp : sample instance
+    index : int, data point index
+    mark : int, 0 for unselected, 1 for set1, 2 for set2
+
+    Returns
+    -------
+
+    """
+    if mark not in [1, 2, '1', '2']:
+        raise ValueError(f"invalid mark value: {mark}, must be 1 or 2.")
+
+    def seq(_i): return [smp.UnselectedSequence, smp.SelectedSequence1, smp.SelectedSequence2][_i]
+
+    if index in seq(mark):
+        seq(mark).remove(index)
+        smp.UnselectedSequence.append(index)
+    else:
+        for i in [0, [0, 2, 1][mark]]:
+            if index in seq(i):
+                seq(i).remove(index)
+        seq(mark).append(index)
+    smp.IsochronMark = [
+        '1' if i in smp.SelectedSequence1 else '2' if i in smp.SelectedSequence2 else '' for i in
+        range(len(smp.IsochronValues[2]))]
+    #
+    smp.Info.results.selection[0]['data'] = smp.SelectedSequence1
+    smp.Info.results.selection[1]['data'] = smp.SelectedSequence2
+    smp.Info.results.selection[2]['data'] = smp.UnselectedSequence

ararpy/smp/calculation.py

@@ -22,7 +22,8 @@ def recalculate(
         re_corr_blank: bool = False, re_corr_massdiscr: bool = False,
         re_corr_decay: bool = False, re_degas_ca: bool = False, re_degas_k: bool = False,
         re_degas_cl: bool = False, re_degas_atm: bool = False, re_degas_r: bool = False,
-        re_calc_ratio: bool = False, re_calc_apparent_age: bool = False, monte_carlo: bool = False,
+        re_calc_ratio: bool = False, re_calc_apparent_age: bool = False,
+        # monte_carlo: bool = False,
         re_plot: bool = False, re_plot_style: bool = False, re_set_table: bool = False,
         re_table_style: bool = False, **kwargs
 ):
@@ -42,7 +43,6 @@ def recalculate(
     re_degas_r
     re_calc_ratio
     re_calc_apparent_age
-    monte_carlo
     re_plot
     re_plot_style
     re_set_table
@@ -59,13 +59,11 @@ def recalculate(
     # print(f"{sample.UnselectedSequence = }")
     # print(f"{sample.SelectedSequence1 = }")
     # print(f"{sample.SelectedSequence2 = }")
+
     # --- initializing ---
-    re_corr_gain = re_corr_blank
     if re_initial:  # 1
         initial.re_set_smp(sample)
     # --- calculating ---
-    if re_corr_gain:  # 2 2024-10-04 add
-        corr.corr_gain(sample)
     if re_corr_blank:  # 2
         corr.corr_blank(sample)
     if re_corr_massdiscr:  # 3
@@ -82,8 +80,10 @@ def recalculate(
         corr.calc_degas_atm(sample)
     if re_degas_r:  # 9
         corr.calc_degas_r(sample)
+        corr.calc_degas_c(sample)
     if re_calc_ratio:  # 10
-        corr.calc_ratio(sample, monte_carlo)
+        corr.calc_ratio(sample)
+        corr.calc_ratio_monte_carlo(sample)
     if re_calc_apparent_age:  # 11
         basic.calc_apparent_ages(sample)
     # --- plot and table ---