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

ararpy/smp/plots.py

@@ -58,117 +58,126 @@ def set_plot_data(sample: Sample, isInit: bool = True, isIsochron: bool = True,
 
     # Initialization, apply age spectra data and isochron plot data
     if isInit:
-        try:
-            initial_plot_data(sample)
-        except (Exception, BaseException):
-            print("initial_plot_data(sample) error:\n", traceback.format_exc())
-            pass
+        initial_plot_data(sample)
+        # try:
+        #     initial_plot_data(sample)
+        # except (Exception, BaseException):
+        #     print("initial_plot_data(sample) error:\n", traceback.format_exc())
+        #     pass
 
     # Recalculate isochron lines
     if isIsochron:
-        try:
-            recalc_isochrons(sample, **kwargs)
-        except (Exception, BaseException):
-            print("recalc_isochrons(sample, **kwargs) error:\n", traceback.format_exc())
-            pass
-        try:
-            reset_isochron_line_data(sample)
-        except (Exception, BaseException):
-            print("reset_isochron_line_data(sample):\n", traceback.format_exc())
-            pass
+        recalc_isochrons(sample, **kwargs)
+        reset_isochron_line_data(sample)
+        # try:
+        #     recalc_isochrons(sample, **kwargs)
+        # except (Exception, BaseException):
+        #     print("recalc_isochrons(sample, **kwargs) error:\n", traceback.format_exc())
+        #     pass
+        # try:
+        #     reset_isochron_line_data(sample)
+        # except (Exception, BaseException):
+        #     print("reset_isochron_line_data(sample):\n", traceback.format_exc())
+        #     pass
 
     # Recalculate plateaus
     if isPlateau:
-        try:
-            recalc_plateaus(sample)
-        except (Exception, BaseException):
-            print("recalc_plateaus(sample) error:\n", traceback.format_exc())
-            pass
+        recalc_plateaus(sample)
+        # try:
+        #     recalc_plateaus(sample)
+        # except (Exception, BaseException):
+        #     print("recalc_plateaus(sample) error:\n", traceback.format_exc())
+        #     pass
 
 
 # =======================
 # Initialize plot data
 # =======================
-def initial_plot_data(sample: Sample):
+def initial_plot_data(smp: Sample):
     """
     Assign initial data for plots
     Parameters
     ----------
-    sample : Sample instance
+    smp : Sample instance
 
     Returns
     -------
     None
     """
+    try:
+        params_to_check = {
+            'normal': {'data': smp.IsochronValues[0:5], 'dtype': float, 'class': 'k1', },
+            'inverse': {'data': smp.IsochronValues[6:11], 'dtype': float, 'class': 'k2', },
+            'K-Cl-Ar 1': {'data': smp.IsochronValues[12:17], 'dtype': float, 'class': 'k3', },
+            'K-Cl-Ar 2': {'data': smp.IsochronValues[18:23], 'dtype': float, 'class': 'k4', },
+            'K-Cl-Ar 3': {'data': smp.IsochronValues[24:29], 'dtype': float, 'class': 'k5', },
+            '3D': {'data': smp.IsochronValues[30:39], 'dtype': float, 'class': 'k6', },
+            'age spectra': [
+                {'data': smp.ApparentAgeValues[2:4], 'dtype': float, 'class': 'k7', },
+                {'data': smp.ApparentAgeValues[7], 'dtype': float, 'class': 'k7', },
+            ],
+            'degas pattern': {'data': smp.IsochronValues[30:39], 'dtype': float, 'class': 'k8', },
+            'age distribution': {'data': smp.IsochronValues[30:39], 'dtype': float, 'class': 'k9', },
+        }
+    except (IndexError, AttributeError) as e:
+        raise
+    if not basic.validate_params(**params_to_check):
+        return
+
+    # Isochron plots
     for key, val in ISOCHRON_INDEX_DICT.items():
-        figure = basic.get_component_byid(sample, key)
-        try:
-            # data = [x, sx, y, sy, (z, sz,) r1, (r2, r3,), index from 1]
-            figure.data = sample.IsochronValues[val['data_index'][0]:val['data_index'][1]] + \
-                          [[i + 1 for i in range(len(sample.SequenceName))]]
-        except (Exception, BaseException):
-            print(traceback.format_exc())
-            figure.data = [[]] * (val['data_index'][1] - val['data_index'][0]) + \
-                          [[i + 1 for i in range(len(sample.SequenceName))]]
-        finally:
-            # Ellipse
-            if key != 'figure_7':
-                ellipse_data = []
-                for point in calc.arr.transpose(figure.data[:5]):
-                    if '' not in point and None not in point:
-                        ellipse_data.append(calc.isochron.get_ellipse(*point))
-                        getattr(figure, 'ellipse', Set(id='ellipse')).data = ellipse_data
-
-    # Set age spectra lines
+        figure = basic.get_component_byid(smp, key)
+        figure.data = [
+            *smp.IsochronValues[val['data_index'][0]:val['data_index'][1]],
+            list(range(smp.Info.experiment.step_num))
+        ]
+        # Ellipse
+        if key != 'figure_7':
+            ellipse_data = []
+            for point in calc.arr.transpose(figure.data[:5]):
+                if '' not in point and None not in point:
+                    ellipse_data.append(calc.isochron.get_ellipse(*point))
+                    getattr(figure, 'ellipse', Set(id='ellipse')).data = ellipse_data
+
+    # Age spectra plot
     # Try to calculate total gas age
     try:
-        a0, e0 = sum(sample.DegasValues[24]), pow(sum([i ** 2 for i in sample.DegasValues[25]]), 0.5)
-        a1, e1 = sum(sample.DegasValues[20]), pow(sum([i ** 2 for i in sample.DegasValues[21]]), 0.5)
+        if str(smp.Info.sample.type).lower() == "unknown":
+            a0, e0 = sum(smp.DegasValues[24]), pow(sum([i ** 2 for i in smp.DegasValues[25]]), 0.5)
+            a1, e1 = sum(smp.DegasValues[20]), pow(sum([i ** 2 for i in smp.DegasValues[21]]), 0.5)
+            handle = basic.calc_age
+        elif str(smp.Info.sample.type).lower() == "standard":
+            a0, e0 = sum(smp.DegasValues[24]), pow(sum([i ** 2 for i in smp.DegasValues[25]]), 0.5)
+            a1, e1 = sum(smp.DegasValues[20]), pow(sum([i ** 2 for i in smp.DegasValues[21]]), 0.5)
+            handle = basic.calc_j
+        elif str(smp.Info.sample.type).lower() == "air":
+            a0, e0 = sum(smp.DegasValues[26]), pow(sum([i ** 2 for i in smp.DegasValues[27]]), 0.5)
+            a1, e1 = sum(smp.DegasValues[ 0]), pow(sum([i ** 2 for i in smp.DegasValues[ 1]]), 0.5)
+            handle = basic.calc_mdf
+        else:
+            raise TypeError(f"Sample type is not supported: {smp.Info.sample.type}")
         total_f = [a0 / a1, calc.err.div((a0, e0), (a1, e1))]
-        total_age = basic.calc_age(total_f[:2], smp=sample)
+        total_age = handle(total_f[:2], smp=smp)
     except (Exception, BaseException):
         print(traceback.format_exc())
         total_f = [np.nan] * 2
         total_age = [np.nan] * 4
-    sample.Info.results.age_spectra['TGA'].update(
+    smp.Info.results.age_spectra['TGA'].update(
         {'Ar39': 100, 'F': total_f[0], 'sF': total_f[1], 'age': total_age[0],
-         's1': total_age[1], 's2': total_age[2], 's3': total_age[3], 'Num': len(sample.DegasValues[24])}
+         's1': total_age[1], 's2': total_age[2], 's3': total_age[3], 'Num': len(smp.DegasValues[24])}
     )
     try:
-        sample.AgeSpectraPlot.data = calc.spectra.get_data(
-            *sample.ApparentAgeValues[2:4], sample.ApparentAgeValues[7])
-        sample.AgeSpectraPlot.data = calc.arr.transpose(sample.AgeSpectraPlot.data)
+        smp.AgeSpectraPlot.data = calc.spectra.get_data(*smp.ApparentAgeValues[2:4], smp.ApparentAgeValues[7])
+        smp.AgeSpectraPlot.data = calc.arr.transpose(smp.AgeSpectraPlot.data)
     except (Exception, BaseException):
         print(traceback.format_exc())
-        sample.AgeSpectraPlot.data = []
+        smp.AgeSpectraPlot.data = []
 
     # Degassing plot
-    try:
-        if not hasattr(sample, 'DegasPatternPlot'):
-            setattr(sample, 'DegasPatternPlot', Plot(id='figure_8', name='Degas Pattern Plot'))
-        isotope_percentage = lambda l: [e / sum(l) * 100 if sum(l) != 0 else 0 for e in l]
-        sample.DegasPatternPlot.data = [
-            isotope_percentage(sample.DegasValues[0]),  # Ar36a
-            isotope_percentage(sample.DegasValues[8]),  # Ar37Ca
-            isotope_percentage(sample.DegasValues[10]),  # Ar38Cl
-            isotope_percentage(sample.DegasValues[20]),  # Ar39K
-            isotope_percentage(sample.DegasValues[24]),  # Ar40r
-            isotope_percentage(sample.CorrectedValues[0]),  # Ar36
-            isotope_percentage(sample.CorrectedValues[2]),  # Ar37
-            isotope_percentage(sample.CorrectedValues[4]),  # Ar38
-            isotope_percentage(sample.CorrectedValues[6]),  # Ar39
-            isotope_percentage(sample.CorrectedValues[8]),  # Ar40
-        ]
-        sample.DegasPatternPlot.info = [True] * 10
-    except Exception as e:
-        print(traceback.format_exc())
-        pass
+    recalc_degassing_plot(smp)
 
-    # Set age distribution plot data
-    try:
-        recalc_agedistribution(sample)
-    except Exception as e:
-        print(traceback.format_exc())
+    # Age distribution plot
+    recalc_agedistribution(smp)
 
 
 # =======================
@@ -236,13 +245,14 @@ def get_isochron_results(data: list, smp: Sample, sequence, figure_type: int = 0
 
     if len(sequence) < 3:
         return iso_res
-    regression_method = {
-        "york-2": calc.regression.york2, "olst": calc.regression.olst
-    }.get(smp.TotalParam[97][min(sequence)].lower(), calc.regression.york2)
     try:
+        regression_method = {
+            "york-2": calc.regression.york2, "olst": calc.regression.olst
+        }.get(smp.TotalParam[97][min(sequence)].lower(), calc.regression.york2)
         regression_res = regression_method(*data[:5])
     except (Exception, BaseException):
-        # print(f"Warning: {traceback.format_exc()}")
+        # print(f"{data[:5] = }")
+        # print(f"Warning Isochron Regression: {traceback.format_exc()}")
         return iso_res
     else:
         iso_res.update(dict(zip(reg_res_index, regression_res)))
@@ -335,50 +345,14 @@ def reset_isochron_line_data(smp: Sample):
     for k, v in basic.get_components(smp).items():
         if not isinstance(v, Plot):
             continue
+        if k not in ['figure_2', 'figure_3', 'figure_4', 'figure_5', 'figure_6', ]:
+            continue
         for index in [0, 1]:
-            try:
-                xscale, yscale = [v.xaxis.min, v.xaxis.max], [v.yaxis.min, v.yaxis.max]
-                coeffs = [smp.Info.results.isochron[k][index]['k'], smp.Info.results.isochron[k][index]['m1']]
-                line_point = calc.isochron.get_line_points(xscale, yscale, coeffs)
-                setattr(getattr(v, ['line1', 'line2'][index]), 'data', line_point)
-                setattr(getattr(v, ['text1', 'text2'][index]), 'text', "")  # 注意和js的配合，js那边根据text是否为空判断是否重新生成文字
-            except Exception:
-                # print(traceback.format_exc())
-                continue
-
-
-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"{mark = }, 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
+            xscale, yscale = [v.xaxis.min, v.xaxis.max], [v.yaxis.min, v.yaxis.max]
+            coeffs = [smp.Info.results.isochron[k][index]['k'], smp.Info.results.isochron[k][index]['m1']]
+            line_point = calc.isochron.get_line_points(xscale, yscale, coeffs)
+            setattr(getattr(v, ['line1', 'line2'][index]), 'data', line_point)
+            setattr(getattr(v, ['text1', 'text2'][index]), 'text', "")  # 注意和js的配合，js那边根据text是否为空判断是否重新生成文字
 
 
 # =======================
@@ -390,7 +364,7 @@ def recalc_plateaus(sample: Sample, **kwargs):
     if sample.Info.sample.type == "Standard":
         return recalc_j_plateaus(sample, **kwargs)
     if sample.Info.sample.type == "Air":
-        return recalc_j_plateaus(sample, **kwargs)
+        return recalc_mdf_plateaus(sample, **kwargs)
 
 
 def recalc_age_plateaus(sample: Sample, **kwargs):
@@ -405,7 +379,7 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
     -------
     None
     """
-    ar39k, sar39k = calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor)
+    ar39k, sar39k = calc.arr.mul(sample.DegasValues[20:22], sample.TotalParam[136:138])
     ar40r, sar40r = sample.DegasValues[24:26]
     ar40rar39k = calc.arr.div([ar40r, sar40r], [ar39k, sar39k])
     params_initial_ratio = calc.arr.partial(sample.TotalParam, cols=list(range(115, 120)))
@@ -437,7 +411,7 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
     try:
         set1_res, set1_age, set1_data = get_plateau_results(
             sample, sample.SelectedSequence1, calc_ar40ar39(*ratio_set1, smp=sample),
-            ar39k_percentage=np.cumsum(ar39k) / np.sum(ar39k),
+            ar39k_percentage=np.array(ar39k) / np.sum(ar39k),
             **kwargs)
     except ValueError:
         # print(traceback.format_exc())
@@ -450,7 +424,7 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
     try:
         set2_res, set2_age, set2_data = get_plateau_results(
             sample, sample.SelectedSequence2, calc_ar40ar39(*ratio_set2, smp=sample),
-            ar39k_percentage=np.cumsum(ar39k) / np.sum(ar39k),
+            ar39k_percentage=np.array(ar39k) / np.sum(ar39k),
             **kwargs)
     except ValueError:
         # print(traceback.format_exc())
@@ -464,7 +438,7 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
     # Weighted mean ages of two sets with 298.56 (defoult air ratio)
     try:
         set1_res = get_wma_results(
-            sample, sample.SelectedSequence1, ar40rar39k=ar40rar39k, ar39k_percentage=np.cumsum(ar39k) / np.sum(ar39k))
+            sample, sample.SelectedSequence1, ar40rar39k=ar40rar39k, ar39k_percentage=np.array(ar39k) / np.sum(ar39k))
     except ValueError:
         pass
         # raise ValueError(f"Set 1 WMA calculation error.")
@@ -472,7 +446,7 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
         sample.Info.results.age_spectra.update({0: set1_res})
     try:
         set2_res = get_wma_results(
-            sample, sample.SelectedSequence2, ar40rar39k=ar40rar39k, ar39k_percentage=np.cumsum(ar39k) / np.sum(ar39k))
+            sample, sample.SelectedSequence2, ar40rar39k=ar40rar39k, ar39k_percentage=np.array(ar39k) / np.sum(ar39k))
     except ValueError:
         pass
         # raise ValueError(f"Set 2 WMA calculation error.")
@@ -552,6 +526,41 @@ def recalc_age_plateaus(sample: Sample, **kwargs):
     # # """end"""
 
 
+def recalc_mdf_plateaus(sample: Sample, **kwargs):
+    """
+    Calculate age plateaus results
+    Parameters
+    ----------
+    sample : sample instance
+    kwargs : optional args, keys in [r1, sr1, r2, sr2]
+
+    Returns
+    -------
+    None
+    """
+    ar36a, sar36a = calc.arr.mul(sample.DegasValues[0:2], sample.TotalParam[136:138])
+    ar40aar36a = sample.ApparentAgeValues[0:2]
+    mdf = sample.ApparentAgeValues[2:4]
+
+    try:
+        set1_res, _, set1_data = get_plateau_results(sample, sample.SelectedSequence1, ar40rar39k=ar40aar36a)
+    except ValueError:
+        pass
+    else:
+        sample.Info.results.age_plateau.update({0: set1_res})
+        sample.AgeSpectraPlot.set1.data = calc.arr.transpose(set1_data)
+        sample.AgeSpectraPlot.text1.text = ""
+
+    try:
+        set2_res, _, set2_data = get_plateau_results(sample, sample.SelectedSequence2, ar40rar39k=ar40aar36a)
+    except ValueError:
+        pass
+    else:
+        sample.Info.results.age_plateau.update({1: set2_res})
+        sample.AgeSpectraPlot.set2.data = calc.arr.transpose(set2_data)
+        sample.AgeSpectraPlot.text2.text = ""
+
+
 def calc_ar40ar39(r, sr, smp):
     """
     Calculate Ar40r / Ar39K based on passed initial ratio.
@@ -567,7 +576,7 @@ def calc_ar40ar39(r, sr, smp):
     """
     try:
         ar36a = np.array(smp.DegasValues[0:2])
-        ar39k = calc.arr.mul(smp.DegasValues[20:22], smp.NormalizeFactor)
+        ar39k = calc.arr.mul(smp.DegasValues[20:22], smp.TotalParam[136:138])
         ar40 = smp.CorrectedValues[8:10]
         ar40k = smp.DegasValues[30:32]
         size = ar36a.shape[-1]
@@ -586,20 +595,20 @@ def calc_ar40ar39(r, sr, smp):
         return ar40rar39k
 
 
-def get_plateau_results(sample: Sample, sequence: list, ar40rar39k: list = None,
+def get_plateau_results(smp: Sample, sequence: list, ar40rar39k: list = None,
                         ar39k_percentage: list = None, **kwargs):
     """
     Get initial ratio re-corrected plateau results
     Parameters
     ----------
-    sample : sample instance
+    smp : sample instance
     sequence : data slice index
     ar40rar39k :
     ar39k_percentage : Ar39K released
 
     Returns
     -------
-    three itmes tuple, result dict, age, and plot data, results keys = [
+    three items tuple, result dict, age, and plot data, results keys = [
         'F', 'sF', 'Num', 'MSWD', 'Chisq', 'Pvalue',
         'age', 's1', 's2', 's3', 'Ar39', 'rs'
     ]
@@ -616,21 +625,28 @@ def get_plateau_results(sample: Sample, sequence: list, ar40rar39k: list = None,
     if len(sequence) == 0:
         return plateau_res, [], []
     if ar40rar39k is None:
-        ar40rar39k = sample.ApparentAgeValues[0:2]
+        ar40rar39k = smp.ApparentAgeValues[0:2]
     if ar39k_percentage is None:
-        ar39k_percentage = sample.ApparentAgeValues[7]
+        ar39k_percentage = smp.ApparentAgeValues[7]
+
+    if str(smp.Info.sample.type).lower() == "unknown":
+        handle = basic.calc_age
+    elif str(smp.Info.sample.type).lower() == "standard":
+        handle = basic.calc_j
+    elif str(smp.Info.sample.type).lower() == "air":
+        handle = basic.calc_mdf
+    else:
+        raise TypeError(f"Sample type is not supported: {smp.Info.sample.type}")
 
-    age = basic.calc_age(ar40ar39=ar40rar39k, smp=sample)[0:2]
+    age = handle(ar40rar39k, smp=smp)[0:2]
     plot_data = calc.spectra.get_data(*age, ar39k_percentage, indices=sequence, **kwargs)
     f_values = _get_partial(sequence, *ar40rar39k)
     age = _get_partial(sequence, *age)
     sum_ar39k = sum(_get_partial(sequence, ar39k_percentage)[0])
     wmf = calc.arr.wtd_mean(*f_values)
-    wmage = basic.calc_age(wmf[0:2], smp=sample)
+    wmage = handle(wmf[0:2], smp=smp)
 
-    plateau_res.update(dict(zip(
-        plateau_res_keys, [*wmf, *wmage, sum_ar39k, np.nan]
-    )))
+    plateau_res.update(dict(zip(plateau_res_keys, [*wmf, *wmage, sum_ar39k, np.nan])))
     return plateau_res, age, plot_data
 
 
@@ -679,13 +695,11 @@ def get_wma_results(sample: Sample, sequence: list, ar40rar39k: list = None, ar3
 
 def recalc_j_plateaus(sample: Sample, **kwargs):
 
-    print(f"Recalc J plateau")
-
+    ar40rar39k = sample.ApparentAgeValues[0:2]
     j = sample.ApparentAgeValues[2:4]
 
     try:
-        set1_res, _, set1_data = \
-            get_j_plateau_results(sample, sample.SelectedSequence1, j)
+        set1_res, _, set1_data = get_plateau_results(sample, sample.SelectedSequence1, ar40rar39k=ar40rar39k)
     except ValueError:
         pass
     else:
@@ -694,8 +708,7 @@ def recalc_j_plateaus(sample: Sample, **kwargs):
         sample.AgeSpectraPlot.text1.text = ""  # 注意和js的配合，js那边根据text是否为空判断是否重新生成文字
 
     try:
-        set2_res, _, set2_data = \
-            get_j_plateau_results(sample, sample.SelectedSequence2, j)
+        set2_res, _, set2_data = get_plateau_results(sample, sample.SelectedSequence2, ar40rar39k=ar40rar39k)
     except ValueError:
         pass
     else:
@@ -704,81 +717,75 @@ def recalc_j_plateaus(sample: Sample, **kwargs):
         sample.AgeSpectraPlot.text2.text = ""  # 注意和js的配合，js那边根据text是否为空判断是否重新生成文字
 
 
-def get_j_plateau_results(sample: Sample, sequence: list, j: list, ar39k_percentage: list = None):
-
-    def _get_partial(points, *args):
-        # return [arg[min(points): max(points) + 1] for arg in args]
-        return [[arg[i] for i in points] for arg in args]
-
-    if ar39k_percentage is None:
-        ar39k_percentage = sample.ApparentAgeValues[7]
-    sum_ar39k = sum(_get_partial(sequence, ar39k_percentage)[0])
-
-    j_values = _get_partial(sequence, *j)
-    wmj = calc.arr.wtd_mean(*j_values)
-    plot_data = [[sum(ar39k_percentage[:min(sequence)]), sum(ar39k_percentage[:max(sequence) + 1])],
-                 [wmj[0], wmj[0]]]
-
-    plateau_res_keys = [
-        'F', 'sF', 'Num', 'MSWD', 'Chisq', 'Pvalue', 'age', 's1', 's2', 's3', 'Ar39',
-        'rs',  # 'rs' means relative error of the total sum
-    ]
-    plateau_res = dict(zip(plateau_res_keys, [np.nan for i in plateau_res_keys]))
-    plateau_res.update(dict(zip(plateau_res_keys, [*wmj, np.nan, np.nan, np.nan, np.nan, sum_ar39k, np.nan])))
-
-    return plateau_res, 0, plot_data
-
-
 # =======================
 # Age Distribution Plot
 # =======================
-def recalc_agedistribution(sample: Sample, **kwargs):
-    for i in range(2):
-        try:
-            # Age bars
-            sample.AgeDistributionPlot.set3.data = calc.arr.remove(sample.ApparentAgeValues[2:4], (None, np.nan))
-            # Set histogram data
-            s = getattr(sample.AgeDistributionPlot.set1, 'bin_start', None)
-            w = getattr(sample.AgeDistributionPlot.set1, 'bin_width', None)
-            c = getattr(sample.AgeDistributionPlot.set1, 'bin_count', None)
-            r = getattr(sample.AgeDistributionPlot.set1, 'bin_rule', None)
-            # print(f's = {s}, r = {r}, w = {w}, c = {c}')
-            histogram_data = calc.histogram.get_data(sample.ApparentAgeValues[2], s=s, r=r, w=w, c=c)
-            sample.AgeDistributionPlot.set1.data = [histogram_data[1], histogram_data[0], histogram_data[2]]  # [half_bins, counts]
-            setattr(sample.AgeDistributionPlot.set1, 'bin_start', histogram_data[3])
-            setattr(sample.AgeDistributionPlot.set1, 'bin_rule', histogram_data[4])
-            setattr(sample.AgeDistributionPlot.set1, 'bin_width', histogram_data[5])
-            setattr(sample.AgeDistributionPlot.set1, 'bin_count', histogram_data[6])
-            h = getattr(sample.AgeDistributionPlot.set2, 'band_width', None)
-            k = getattr(sample.AgeDistributionPlot.set2, 'band_kernel', 'normal')
-            t = getattr(sample.AgeDistributionPlot.set2, 'band_extend', False)
-            a = getattr(sample.AgeDistributionPlot.set2, 'auto_width', 'Scott')
-            n = getattr(sample.AgeDistributionPlot.set2, 'band_points', 1000)
-            # print(f'h = {h}, k = {k}, a = {a}, n = {n}, extend = {t}')
-            kda_data = calc.histogram.get_kde(
-                sample.ApparentAgeValues[2], h=h, k=k, n=n, a=a,
-                s=float(getattr(sample.AgeDistributionPlot.xaxis, 'min')) if t else histogram_data[3],
-                e=float(getattr(sample.AgeDistributionPlot.xaxis, 'max')) if t else histogram_data[7],
-            )
-            sample.AgeDistributionPlot.set2.data = kda_data[0]  # [values, kda]
-            setattr(sample.AgeDistributionPlot.set2, 'band_width', kda_data[1])
-            setattr(sample.AgeDistributionPlot.set2, 'band_kernel', kda_data[2])
-            setattr(sample.AgeDistributionPlot.set2, 'auto_width', kda_data[3])
-            # sorted_data = [i[0] for i in sorted(zipped_data, key=lambda x: x[1])]
-            text = f'n = {len(sample.ApparentAgeValues[2])}'
-            peaks = find_peaks(kda_data[0][1])
-            for index, peak in enumerate(peaks[0].tolist()):
-                text = text + f'\nPeak {index}: {kda_data[0][0][peak]:.2f}'
-            setattr(sample.AgeDistributionPlot.text1, 'text', text)
-        except AttributeError:
-            print(traceback.format_exc())
-            initial.re_set_smp(sample)
-            continue
-        except (Exception, BaseException):
-            print(traceback.format_exc())
-            sample.AgeDistributionPlot.data = [[], []]
-            sample.AgeDistributionPlot.set1.data = [[], []]
-            sample.AgeDistributionPlot.set2.data = [[], []]
-        break
+def recalc_agedistribution(smp: Sample, **kwargs):
+    try:
+        ages = smp.ApparentAgeValues[2]
+        plot = smp.AgeDistributionPlot
+        # Set3: Age bars
+        plot.set3.data = calc.arr.remove(smp.ApparentAgeValues[2:4], (None, np.nan))
+
+        # Set1: Histogram data
+        s = getattr(plot.set1, 'bin_start', None)
+        w = getattr(plot.set1, 'bin_width', None)
+        c = getattr(plot.set1, 'bin_count', None)
+        r = getattr(plot.set1, 'bin_rule', None)
+        # print(f's = {s}, r = {r}, w = {w}, c = {c}')
+        histogram_data = calc.histogram.get_data(ages, s=s, r=r, w=w, c=c)
+        plot.set1.data = [histogram_data[1], histogram_data[0], histogram_data[2]]  # [half_bins, counts]
+        setattr(plot.set1, 'bin_start', histogram_data[3])
+        setattr(plot.set1, 'bin_rule', histogram_data[4])
+        setattr(plot.set1, 'bin_width', histogram_data[5])
+        setattr(plot.set1, 'bin_count', histogram_data[6])
+        h = getattr(plot.set2, 'band_width', None)
+        k = getattr(plot.set2, 'band_kernel', 'normal')
+        t = getattr(plot.set2, 'band_extend', False)
+        a = getattr(plot.set2, 'auto_width', 'Scott')
+        n = getattr(plot.set2, 'band_points', 1000)
+        # print(f'h = {h}, k = {k}, a = {a}, n = {n}, extend = {t}')
+        kda_data = calc.histogram.get_kde(
+            ages, h=h, k=k, n=n, a=a,
+            s=float(getattr(plot.xaxis, 'min')) if t else histogram_data[3],
+            e=float(getattr(plot.xaxis, 'max')) if t else histogram_data[7],
+        )
+
+        # Set2: KDA data
+        plot.set2.data = kda_data[0]  # [values, kda]
+        setattr(plot.set2, 'band_width', kda_data[1])
+        setattr(plot.set2, 'band_kernel', kda_data[2])
+        setattr(plot.set2, 'auto_width', kda_data[3])
+        # sorted_data = [i[0] for i in sorted(zipped_data, key=lambda x: x[1])]
+        text = f'n = {len(ages)}'
+        peaks = find_peaks(kda_data[0][1])
+        for index, peak in enumerate(peaks[0].tolist()):
+            text = text + f'\nPeak {index}: {kda_data[0][0][peak]:.2f}'
+        setattr(plot.text1, 'text', text)
+    except (Exception, BaseException):
+        print(traceback.format_exc())
+        plot.data = [[], []]
+        plot.set1.data = [[], []]
+        plot.set2.data = [[], []]
 
 
+# =======================
+# Age Distribution Plot
+# =======================
+def recalc_degassing_plot(smp: Sample, **kwargs):
+    if not hasattr(smp, 'DegasPatternPlot'):
+        setattr(smp, 'DegasPatternPlot', Plot(id='figure_8', name='Degas Pattern Plot'))
+    isotope_percentage = lambda l: [e / sum(l) * 100 if sum(l) != 0 else 0 for e in l]
+    smp.DegasPatternPlot.data = [
+        isotope_percentage(smp.DegasValues[0]),  # Ar36a
+        isotope_percentage(smp.DegasValues[8]),  # Ar37Ca
+        isotope_percentage(smp.DegasValues[10]),  # Ar38Cl
+        isotope_percentage(smp.DegasValues[20]),  # Ar39K
+        isotope_percentage(smp.DegasValues[24]),  # Ar40r
+        isotope_percentage(smp.CorrectedValues[0]),  # Ar36
+        isotope_percentage(smp.CorrectedValues[2]),  # Ar37
+        isotope_percentage(smp.CorrectedValues[4]),  # Ar38
+        isotope_percentage(smp.CorrectedValues[6]),  # Ar39
+        isotope_percentage(smp.CorrectedValues[8]),  # Ar40
+    ]
+    smp.DegasPatternPlot.info = [True] * 10