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

ararpy/smp/corr.py

@@ -25,16 +25,15 @@ from .sample import Sample
 def corr_gain(sample: Sample):
     """Blank Correction"""
     corrGain = True
-    gain_corrected = np.zeros([10, len(sample.SequenceName)])
+    gain_corrected = np.zeros([10, sample.Info.experiment.step_num])
     try:
         for i in range(5):
             f, sf = np.array(sample.TotalParam[126 + i * 2:128 + i * 2])
             sf = f * sf / 100
             gain_corrected[i * 2:2 + i * 2] = calc.corr.gain(*sample.SampleIntercept[i * 2:2 + i * 2], f, sf)
-    except Exception as e:
-        print(f"Gain correction failed")
-        print(traceback.format_exc())
-        return
+    except (Exception, BaseException) as e:
+        print(f"Gain correction failed: \n{traceback.format_exc()}")
+        raise
     for i in range(0, 10, 2):
         gain_corrected[i] = [gain_corrected[i][index] if corrGain else j for index, j in enumerate(sample.SampleIntercept[i])]
         gain_corrected[i + 1] = [gain_corrected[i + 1][index] if corrGain else j for index, j in enumerate(sample.SampleIntercept[i + 1])]
@@ -156,15 +155,12 @@ def calc_degas_ca(sample: Sample):
     ar39ca = calc.arr.mul_factor(ar37ca, sample.TotalParam[8:10], isRelative=True)
     ar38ca = calc.arr.mul_factor(ar37ca, sample.TotalParam[10:12], isRelative=True)
     ar36ca = calc.arr.mul_factor(ar37ca, sample.TotalParam[12:14], isRelative=True)
-    sample.DegasValues[8:10] = copy.deepcopy(ar37ca)
-    # sample.DegasValues[22:24] = ar39ca if corrDecasCa else [[0] * n, [0] * n]
-    # sample.DegasValues[18:20] = ar38ca if corrDecasCa else [[0] * n, [0] * n]
-    # sample.DegasValues[4:6] = ar36ca if corrDecasCa else [[0] * n, [0] * n]
-    sample.DegasValues[ 4] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar36ca[0])]
+    sample.DegasValues[8:10] = copy.deepcopy(ar37ca)  # 37Ca
+    sample.DegasValues[ 4] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar36ca[0])]  # 36Ca
     sample.DegasValues[ 5] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar36ca[1])]
-    sample.DegasValues[18] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar38ca[0])]
+    sample.DegasValues[18] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar38ca[0])]  # 38Ca
     sample.DegasValues[19] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar38ca[1])]
-    sample.DegasValues[22] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar39ca[0])]
+    sample.DegasValues[22] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar39ca[0])]  # 39Ca
     sample.DegasValues[23] = [val if corrDecasCa[idx] else 0 for idx, val in enumerate(ar39ca[1])]
     sample.PublishValues[1] = copy.deepcopy(ar37ca[0])
 
@@ -241,43 +237,51 @@ def calc_degas_cl(sample: Sample):
     try:
         if not corrDecasCl:
             raise ValueError("Do not apply degas chlorine")
-        v3 = [cl36_cl38_p[0][i] * (1 - np.exp(-1 * decay_const[0][i] * stand_time_year[i])) for i in
+        vDecay = [cl36_cl38_p[0][i] * (1 - np.exp(-1 * decay_const[0][i] * stand_time_year[i])) for i in
               range(len(stand_time_year))]
-        s3 = [pow((cl36_cl38_p[1][i] * (1 - np.exp(-1 * decay_const[0][i] * stand_time_year[i]))) ** 2 +
+        sDecay = [pow((cl36_cl38_p[1][i] * (1 - np.exp(-1 * decay_const[0][i] * stand_time_year[i]))) ** 2 +
                   (cl36_cl38_p[0][i] * stand_time_year[i] * (np.exp(-1 * decay_const[0][i] * stand_time_year[i])) *
                    decay_const[1][i]) ** 2, 0.5) for i in range(len(stand_time_year))]
-        s3 = [calc.err.div((1, 0), (v3[i], s3[i])) for i in range(len(s3))]
-        v3 = [1 / v3[i] for i in range(len(v3))]
+        sDecay = [calc.err.div((1, 0), (vDecay[i], sDecay[i])) for i in range(len(sDecay))]
+        vDecay = [1 / vDecay[i] for i in range(len(vDecay))]
+
         # 36ArCl
         ar36cl = [[], []]
-        ar36cl[0] = [(ar36acl[0][i] * ar38ar36[0][i] - ar38acl[0][i]) / (ar38ar36[0][i] - v3[i])
-                     for i in range(len(ar36acl[0]))]
-        s1 = [(ar36acl[1][i] * ar38ar36[0][i] / (ar38ar36[0][i] - v3[i])) ** 2 for i in range(len(ar36cl[0]))]
-        s2 = [(ar38acl[1][i] / (ar38ar36[0][i] - v3[i])) ** 2 for i in range(len(ar36cl[0]))]
-        s3 = [(s3[i] * (ar36acl[0][i] * ar38ar36[0][i] - ar38acl[0][i]) / (ar38ar36[0][i] - v3[i]) ** 2) ** 2
-              for i in range(len(ar36cl[0]))]
-        s4 = [(ar36acl[0][i] / (ar38ar36[0][i] - v3[i]) -
-               (ar36acl[0][i] * ar38ar36[0][i] - ar38acl[0][i]) / (ar38ar36[0][i] - v3[i]) ** 2) ** 2 *
-              (ar38ar36[1][i]) ** 2 for i in range(len(ar36cl[0]))]
-        ar36cl[1] = [pow(s1[i] + s2[i] + s3[i] + s4[i], 0.5) for i in range(len(ar36cl[0]))]
-
         # 38ArCl
         ar38cl = [[], []]
-        ar38cl[1] = [calc.err.mul((ar36cl[0][i], ar36cl[1][i]), (v3[i], s3[i])) for i in range(len(ar36cl[0]))]
-
-        # Negative number set to zero
-        ar36cl[0] = [0 if i < 0 and set_negative_zero else i for i in ar36cl[0]]
-        # force 36ArCl to zero if 36Ar - 36ArCa - 36Cl < 0
-        ar36cl[0] = [0 if ar36acl[0][i] - item < 0 and set_negative_zero else item
-                     for i, item in enumerate(ar36cl[0])]
-
-        ar38cl[0] = [ar36cl[0][i] * v3[i] for i in range(len(ar36cl[0]))]
+        for i in range(len(vDecay)):
+            a1 = sample.CorrectedValues[0][i]; s1 = sample.CorrectedValues[1][i]
+            a2 = sample.DegasValues[4][i]; s2 = sample.DegasValues[5][i];
+            a3 =  sample.DegasValues[16][i]; s3 = sample.DegasValues[17][i]
+            a4 =  sample.DegasValues[18][i]; s4 = sample.DegasValues[19][i]
+            a5 =  sample.CorrectedValues[4][i]; s5 = sample.CorrectedValues[5][i]
+            a6 = vDecay[i]; s6 = sDecay[i]
+            a7 = ar38ar36[0][i]; s7 = ar38ar36[1][i]
+
+            d1 = 1 / (1 - a6 / a7)
+            d2 = - 1 / (1 - a6 / a7)
+            d3 = 1 / (a7 - a6)
+            d4 = 1 / (a7 - a6)
+            d5 = - 1 / (a7 - a6)
+            d6 = (a1 - a2 + (a3 + a4) / a7 - a5 / a7) / a7 / (1 - a6 / a7) ** 2
+            d7 = -(a1 - a2) * (a6) / (a7 - a6) ** 2 - (a3 + a4 - a5) / (a7 - a6) ** 2
+
+            v1 = (a1 - a2 + (a3 + a4) / a7 - a5 / a7) / (1 - a6 / a7)
+            s1 = (d1**2*s1**2 + d2**2*s2**2 + d3**2*s3**2 + d4**2*s4**2+ d5**2*s5**2 + d6**2*s6**2 + d7**2*s7**2) ** .5
+            s2 = calc.err.mul((v1, s1), (vDecay[i], sDecay[i]))
+            v1 = 0 if (ar36acl[0][i] - v1 < 0 or v1 < 0) and set_negative_zero[i] else v1
+            v2 = v1 * vDecay[i]
+
+            # Note: Ar36Cl uncertainty is differen with ArArCALC. All calculation was conducted separately considering they are independent
+            # s1 = calc.err.div((a1 - a2 + (a3 + a4) / a7 - a5 / a7, calc.err.add(s1, s2, calc.err.div((a3 + a4, calc.err.add(s3, s4)), (a7, s7)), calc.err.div((a5, s5), (a7, s7)))), (1 - a6 / a7, calc.err.div((a6, s6), (a7, s7))))
+
+            ar36cl[0].append(v1); ar36cl[1].append(s1)
+            ar38cl[0].append(v2); ar38cl[1].append(s2)
 
     except Exception as e:
         print('Error in corr Cl: {}, lines: {}'.format(e, e.__traceback__.tb_lineno))
-        n = len(ar36acl[0])
-        ar36cl = np.zeros([2, n])
-        ar38cl = np.zeros([2, n])
+        ar36cl = np.zeros([2, len(ar36acl[0])])
+        ar38cl = np.zeros([2, len(ar36acl[0])])
 
     # sample.DegasValues[6:8] = ar36cl
     # sample.DegasValues[10:12] = ar38cl
@@ -349,7 +353,7 @@ def calc_degas_r(sample: Sample):
     """
     ar40ar = calc.arr.sub(sample.CorrectedValues[8:10], sample.DegasValues[30:32])
     ar40r = calc.arr.sub(ar40ar, sample.DegasValues[26:28])
-    ar40r[0] = [item if item >= 0 else 0 for item in ar40r[0]]
+    ar40r[0] = [0 if item < 0 and sample.TotalParam[101][index] else item for index, item in enumerate(ar40r[0])]
     sample.DegasValues[24:26] = copy.deepcopy(ar40r)
     sample.PublishValues[4] = copy.deepcopy(ar40r[0])
 
@@ -360,11 +364,16 @@ def calc_degas_r(sample: Sample):
 def calc_nor_inv_isochrons(sample: Sample):
     n = len(sample.SequenceName)
     try:
-        isochron_1 = calc.isochron.get_data(*sample.DegasValues[20:22], *calc.arr.sub(
-            sample.CorrectedValues[8:10], sample.DegasValues[30:32]), *sample.DegasValues[0:2])
-        isochron_2 = calc.isochron.get_data(*sample.DegasValues[20:22], *sample.DegasValues[0:2], *calc.arr.sub(
-            sample.CorrectedValues[8:10], sample.DegasValues[30:32]))
-    except:
+        isochron_1 = calc.isochron.get_data(
+            *calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor),
+            *calc.arr.sub(sample.CorrectedValues[8:10], sample.DegasValues[30:32]),
+            *sample.DegasValues[0:2]
+        )
+        isochron_2 = calc.isochron.get_data(
+            *calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor),
+            *sample.DegasValues[0:2],
+            *calc.arr.sub(sample.CorrectedValues[8:10], sample.DegasValues[30:32]))
+    except (BaseException, Exception):
         return np.zeros([5, n]), np.zeros([5, n])
     else:
         return isochron_1, isochron_2
@@ -374,12 +383,18 @@ def calc_cl_isochrons(sample: Sample):
     n = len(sample.SequenceName)
     try:
         isochron_3 = calc.isochron.get_data(
-            *sample.DegasValues[20:22], *sample.DegasValues[24:26], *sample.DegasValues[10:12])
+            *calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor),
+            *sample.DegasValues[24:26],
+            *calc.arr.mul(sample.DegasValues[10:12], sample.NormalizeFactor))
         isochron_4 = calc.isochron.get_data(
-            *sample.DegasValues[20:22], *sample.DegasValues[10:12], *sample.DegasValues[24:26])
+            *calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor),
+            *calc.arr.mul(sample.DegasValues[10:12], sample.NormalizeFactor),
+            *sample.DegasValues[24:26])
         isochron_5 = calc.isochron.get_data(
-            *sample.DegasValues[10:12], *sample.DegasValues[24:26], *sample.DegasValues[20:22])
-    except:
+            *calc.arr.mul(sample.DegasValues[10:12], sample.NormalizeFactor),
+            *sample.DegasValues[24:26],
+            *calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor))
+    except (BaseException, Exception):
         return np.zeros([5, n]), np.zeros([5, n]), np.zeros([5, n])
     else:
         return isochron_3, isochron_4, isochron_5
@@ -422,7 +437,6 @@ def calc_ratio(sample: Sample, monte_carlo: bool = False):
     """
     ar40r_percent = [item / sample.CorrectedValues[8][index] * 100 if sample.CorrectedValues[8][index] != 0 else 0
                      for index, item in enumerate(sample.DegasValues[24])]
-    sum_ar39k = sum(sample.DegasValues[20])
     sum_ar36a = sum(sample.DegasValues[ 0])
     CaK = calc.arr.mul_factor(calc.arr.mul_factor(
         sample.DegasValues[8:10], calc.arr.rec_factor(sample.DegasValues[20:22], isRelative=False)),
@@ -437,10 +451,12 @@ def calc_ratio(sample: Sample, monte_carlo: bool = False):
         sample.ApparentAgeValues[0:2] = ar40aar36a
         sample.ApparentAgeValues[7] = ar36a_percent
     else:
+        ar39k, sar39k = calc.arr.mul(sample.DegasValues[20:22], sample.NormalizeFactor)
+        sum_ar39k = sum(ar39k)
+        ar39k_percent = [item / sum_ar39k * 100 if sum_ar39k != 0 else 0 for item in ar39k]
         ar40rar39k = calc.arr.mul_factor(
             sample.DegasValues[24:26], calc.arr.rec_factor(sample.DegasValues[20:22], isRelative=False),
             isRelative=False)
-        ar39k_percent = [item / sum_ar39k * 100 if sum_ar39k != 0 else 0 for item in sample.DegasValues[20]]
         sample.ApparentAgeValues[0:2] = ar40rar39k
         sample.ApparentAgeValues[7] = ar39k_percent
 
@@ -529,6 +545,7 @@ def monte_carlo_f(sample: Sample):
     R36v38clp = np.transpose(sample.TotalParam[56:58])
 
     stand_time_year = np.transpose(sample.TotalParam[32])
+    JNFactor = sample.NormalizeFactor
 
     irradiation_cycles = [list(filter(None, re.split(r'[DS]', each_step))) for each_step in sample.TotalParam[27]]
     t1 = [re.findall(r"\d+", i) for i in sample.TotalParam[31]]  # t1: experimental times
@@ -562,6 +579,7 @@ def monte_carlo_f(sample: Sample):
             L37ar=L37ar[i], L39ar=L39ar[i], L36cl=L36cl[i],
             MDFunc=None,
             MDF=MDF[i], stand_time_year=stand_time_year[i],
+            JNFactor=JNFactor,
             blank_gain_corr=sample.TotalParam[111][i]
         )
 

ararpy/smp/export.py

@@ -38,8 +38,8 @@ except ModuleNotFoundError:
     SETTINGS_ROOT = ""
 
 
-def to_excel(file_path: str):
-    excel = WritingWorkbook(filepath=file_path)
+def to_excel(smp: Sample, file_path: str, *args, **kwargs):
+    excel = WritingWorkbook(sample=smp, filepath=file_path, *args, **kwargs)
     excel.get_xls()
 
 
@@ -297,6 +297,24 @@ def get_plot_series_data(smp: Sample, diagram: str = 'age spectra', **options):
     return series
 
 
+def spectraData2Sgima(data, sigma=2):
+    return list(map(lambda row: [row[0], (row[1] - row[2]) / 2 * (sigma - 1) + row[1], (row[2] - row[1]) / 2 * (sigma - 1) + row[2]], data))
+
+
+def getRectFromSpectra(data):
+    """
+    Parameters
+    ----------
+    data: [x, y1, y2]
+
+    Returns
+    -------
+
+    """
+    data = np.array(data)
+    return list(map(lambda index: [data[index,0], min(data[index,[1,2]]), np.diff(data[[index,index+1],0])[0], np.diff(data[index,[1,2]])[0]], list(range(len(data) - 1))))
+
+
 def _get_additional_text_series(name):
     return {
         'type': 'text', 'id': f'text-{name}-{get_random_digits()}',
@@ -330,22 +348,42 @@ def _get_plot_data_age_spectra_series(smp: sample, **options):
     })
     text1 = smp.AgeSpectraPlot.text1
     text2 = smp.AgeSpectraPlot.text2
+    sigma = 1
+    set_data = [spectraData2Sgima(smp.AgeSpectraPlot.set1.data, sigma),
+                spectraData2Sgima(smp.AgeSpectraPlot.set2.data, sigma)]
     for index, text in enumerate([text1, text2]):
-        if not np.isnan(smp.Info.results.age_spectra[index]['age']):
+        res = smp.Info.results.age_plateau[index]
+        if not np.isnan(res['age']):
             selection = np.array(smp.Info.results.selection[index]['data']) * 2 + 1
-            set_data = list(map(lambda each: [data[0][each - 1], min(data[1][each], data[2][each]), data[0][each + 1] - data[0][each], sigma * abs(data[1][each] - data[2][each])], selection))
+            plateau_data = np.array(set_data[index])
+            # spectra_fill_data = list(map(lambda each: [data[0][each - 1], min(data[1][each], data[2][each]), data[0][each + 1] - data[0][each], sigma * abs(data[1][each] - data[2][each])], selection))
+            spectra_fill_data = getRectFromSpectra(plateau_data)
             series.append({
                 'type': 'series.rect', 'id': f'rect-{smp.name()}-{get_random_digits()}', 'name': f'rect-{smp.name()}-{get_random_digits()}',
-                'color': 'none', 'fill_color': ['red', 'blue'][index], 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
-                'data': set_data, 'line_caps': 'square', 'fill': True,
+                'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index], 'line_width': 0, 'line_style': 'solid', 'z_index': 9,
+                'data': spectra_fill_data, 'line_caps': 'square', 'fill': True,
+                'axis_index': 0,
+            })
+            series.append({
+                'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}',
+                'name': f'line-{smp.name()}-{get_random_digits()}',
+                'color': ['red', 'blue'][index], 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
+                'data': plateau_data[:,[0,1]].tolist(), 'line_caps': 'square',
+                'axis_index': 0,
+            })
+            series.append({
+                'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}',
+                'name': f'line-{smp.name()}-{get_random_digits()}',
+                'color': ['red', 'blue'][index], 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
+                'data': plateau_data[:,[0,2]].tolist(), 'line_caps': 'square',
                 'axis_index': 0,
             })
             series.append({
                 'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}', 'name': f'text-{smp.name()}-{get_random_digits()}',
                 'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index],
-                'text': f"WMPA = {smp.Info.results.age_spectra[index]['age']:.2f} ± {(sigma * smp.Info.results.age_spectra[index]['s3']):.2f} Ma<r>"
-                        f"MSWD = {smp.Info.results.age_spectra[index]['MSWD']:.2f}, n = {smp.Info.results.age_spectra[index]['Num']:.0f}<r>"
-                        f"<sup>39</sup>Ar = {smp.Info.results.age_spectra[index]['Ar39']:.2f}%",
+                'text': f"WMPA = {res['age']:.2f} ± {(sigma * res['s3']):.2f} Ma<r>"
+                        f"MSWD = {res['MSWD']:.2f}, n = {res['Num']:.0f}<r>"
+                        f"<sup>39</sup>Ar = {res['Ar39']:.2f}%",
                 'size': title_size,
                 'data': [text.pos],
                 'axis_index': 1,
@@ -386,10 +424,15 @@ def _get_plot_data_age_spectra_axis(smp: sample, **options):
     y_low_limit, y_up_limit, stick_num, inc = get_axis_scale(np.array(data[1:3]).flatten())
     y_extent = [y_low_limit, y_up_limit]
     y_interval = [y_low_limit + i * inc for i in range(stick_num + 1)]
+    y_interval.extend([y_up_limit * 10] * 3)
+    dp = int(np.log10(abs(y_up_limit - y_low_limit)) - 1)
+    dp = 0 if dp >= 0 else abs(dp)
+    print(f"{dp = }")
+    y_interval = [f"{i:.{dp}f}" for i in y_interval]
 
-    y_extent = [4, 12]
-    y_interval = ['0', '10', '20', '30', '40', '50', '60', '70', '80', '90', '100']
-    y_interval = ['0', '4', '6', '8', '10', '12', '60', '70', '80', '90', '100']
+    # y_extent = [4, 12]
+    # y_interval = ['0', '10', '20', '30', '40', '50', '60', '70', '80', '90', '100']
+    # y_interval = ['0', '4', '6', '8', '10', '12', '60', '70', '80', '90', '100']
 
     xAxis.append({
         'extent': [0, 100], 'interval': [0, 20, 40, 60, 80, 100], 'id': 0, 'show_frame': True,
@@ -762,16 +805,6 @@ class WritingWorkbook:
 
         if self.template_filepath is not None:
             self.read_template()
-        if self.style is None:
-            self.style = {
-                'font_size': 10, 'font_name': 'Microsoft Sans Serif', 'bold': False,
-                'bg_color': '#FFFFFF',  # back ground
-                'font_color': '#000000', 'align': 'left',
-                'top': 1, 'left': 1, 'right': 1, 'bottom': 1  # border width
-            }
-
-    def spectraData2Sgima(self, data, sigma=2):
-        return list(map(lambda row: [row[0], (row[1] - row[2]) / 2 * (sigma - 1) + row[1], (row[2] - row[1]) / 2 * (sigma - 1) + row[2]], data))
 
     def read_template(self):
         # print(self.template_filepath)
@@ -781,7 +814,7 @@ class WritingWorkbook:
         # TypeError: NAN/INF not supported in write_number() without 'nan_inf_to_errors' Workbook() option
         xls = Workbook(self.filepath, {"nan_inf_to_errors": True})
 
-        style = xls.add_format(self.style)
+        style = xls.add_format(self.default_fmt_prop)
 
         sigma = int(self.sample.Info.preference['confidenceLevel'])
 
@@ -809,9 +842,9 @@ class WritingWorkbook:
 
         # Data for age spectra
         try:
-            spectra_data = arr.transpose(self.spectraData2Sgima(self.sample.AgeSpectraPlot.data, sigma))
-            spectra_set1_data = arr.transpose(self.spectraData2Sgima(self.sample.AgeSpectraPlot.set1.data, sigma)) or [[]] * 3
-            spectra_set2_data = arr.transpose(self.spectraData2Sgima(self.sample.AgeSpectraPlot.set2.data, sigma)) or [[]] * 3
+            spectra_data = arr.transpose(spectraData2Sgima(self.sample.AgeSpectraPlot.data, sigma))
+            spectra_set1_data = arr.transpose(spectraData2Sgima(self.sample.AgeSpectraPlot.set1.data, sigma)) or [[]] * 3
+            spectra_set2_data = arr.transpose(spectraData2Sgima(self.sample.AgeSpectraPlot.set2.data, sigma)) or [[]] * 3
             sht_reference.write_column(f"A{start_row}", spectra_data[0], style)
             sht_reference.write_column(f"B{start_row}", spectra_data[1], style)
             sht_reference.write_column(f"C{start_row}", spectra_data[2], style)
@@ -1036,7 +1069,7 @@ class WritingWorkbook:
         material = self.sample.Info.sample.material
         weight = self.sample.Info.sample.weight
         J_value = self.sample.TotalParam[67][0]
-        J_error = self.sample.TotalParam[68][0]
+        J_error = self.sample.TotalParam[68][0] * self.sample.TotalParam[67][0] / 100
         sigma = self.sample.Info.preference['confidenceLevel']
         sequence_type = {"StepLaser": "Laser", "StepFurnace": "Temperature", "StepCrusher": "Drop", }.get(method, "Step Value")
         sequence_unit = self.sample.Info.sample.sequence_unit if self.sample.Info.sample.sequence_unit != "" else "Unit"
@@ -1046,27 +1079,27 @@ class WritingWorkbook:
         set2_ratio = [self.sample.Info.results.isochron['figure_3'][1]['initial'], self.sample.Info.results.isochron['figure_2'][1]['initial'], self.sample.TotalParam[118][0]][int(self.sample.TotalParam[115][0])]
 
         content = [
-            [(0, 0, 0, 14), f"Table 1. 40Ar/39Ar dating results", {'bold': 1, 'top': 1, 'bottom': 1, 'align': 'left'}],
-            [(1, 0, 2, 0), f"Step", {'bold': 1}],
-            [(1, 1), f"{sequence_type}", {'bold': 1}],
-            [(2, 1), f"({sequence_unit})", {'bold': 1}],
-            [(1, 2, 2, 2), f"Set", {'bold': 1}],
-            [(1, 3, 2, 3), f"36Arair", {'bold': 1}],
-            [(1, 4, 2, 4), f"36ArCa", {'bold': 1}],
-            [(1, 5, 2, 5), f"36ArCl", {'bold': 1}],
-            [(1, 6, 2, 6), f"36ArK", {'bold': 1}],
-            [(1, 7, 2, 7), f"36Ar*", {'bold': 1}],
-            [(1, 8, 2, 8), f"39Ar/40Ar", {'bold': 1}],
-            [(1, 9, 2, 9), f"36Ar/40Ar", {'bold': 1}],
-            [(1, 10), f"Apparent Age", {'bold': 1}],
-            [(1, 11), f"± {sigma} σ", {'bold': 1}],
-            [(2, 10, 2, 11), f"({age_unit})", {'bold': 1}],
-            [(1, 12), f"40Ar*", {'bold': 1}],
-            [(2, 12), f"(%)", {'bold': 1}],
-            [(1, 13), f"39ArK", {'bold': 1}],
-            [(2, 13), f"(%)", {'bold': 1}],
-            [(1, 14, 2, 14), f"Ca/K", {'bold': 1}],
-            [(3, 0, 3, 14), f"Sample {name} ({material}){' by ' if method != '' else ''}{method}, weight = {weight} mg, J = {J_value} ± {J_error}", {'bold': 1, 'italic': 1, 'top': 6, 'align': 'left'}],
+            [(0, 0), f"Table 1. 40Ar/39Ar dating results", {'bold': 1, 'top': 1, 'align': 'left'}],
+            [(1, 0, 2, 0), f"Step", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 1), f"{sequence_type}", {'bold': 1, 'top': 1}],
+            [(2, 1), f"({sequence_unit})", {'bold': 1, 'bottom': 6}],
+            [(1, 2, 2, 2), f"Set", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 3, 2, 3), f"36Arair", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 4, 2, 4), f"37ArCa", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 5, 2, 5), f"38ArCl", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 6, 2, 6), f"39ArK", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 7, 2, 7), f"40Ar*", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 8, 2, 8), f"39Ar/40Ar", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 9, 2, 9), f"36Ar/40Ar", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(1, 10), f"Apparent Age", {'bold': 1, 'top': 1}],
+            [(1, 11), f"± {sigma} σ", {'bold': 1, 'top': 1}],
+            [(2, 10, 2, 11), f"({age_unit})", {'bold': 1, 'bottom': 6}],
+            [(1, 12), f"40Ar*", {'bold': 1, 'top': 1}],
+            [(2, 12), f"(%)", {'bold': 1, 'bottom': 6}],
+            [(1, 13), f"39ArK", {'bold': 1, 'top': 1}],
+            [(2, 13), f"(%)", {'bold': 1, 'bottom': 6}],
+            [(1, 14, 2, 14), f"Ca/K", {'bold': 1, 'top': 1, 'bottom': 6}],
+            [(3, 0), f"Sample {name} ({material}){' by ' if method != '' else ''}{method}, weight = {weight} mg, J = {J_value} ± {J_error}", {'bold': 1, 'italic': 1, 'align': 'left'}],
             [(4, 0, 1), self.sample.SequenceName, {'align': 'left'}],
             [(4, 1, 1), self.sample.SequenceValue, {'num_format': 'General'}],
             [(4, 2, 1), list(map(lambda x: int(x) if str(x).isnumeric() else "", self.sample.IsochronMark)), {'num_format': 'General'}],
@@ -1084,7 +1117,7 @@ class WritingWorkbook:
             [(4, 14, 1), self.sample.PublishValues[9], {}],
             [(4 + num_step, 0, 0), [''] * 15, {'bold': 1, 'top': 1}],
 
-            [(5 + num_step, 0, 5 + num_step, 8), "Table 2. 40Ar/39Ar age summary", {'bold': 1, 'align': 'left'}],
+            [(5 + num_step, 0), "Table 2. 40Ar/39Ar age summary", {'bold': 1, 'align': 'left'}],
             [(6 + num_step, 0, 7 + num_step, 0), "Group", {'bold': 1, 'top': 1}],
             [(6 + num_step, 1, 7 + num_step, 1), "40Arr/39K", {'bold': 1, 'top': 1}],
             [(6 + num_step, 2, 7 + num_step, 2), f"± {sigma} σ", {'bold': 1, 'top': 1}],

ararpy/smp/initial.py

@@ -16,7 +16,7 @@ import pandas as pd
 import numpy as np
 import copy
 from typing import List, Union, Optional
-from ..calc import arr
+from ..calc import arr, err
 from ..files import calc_file
 from . import (sample as samples, basic, table, raw as smp_raw)
 
@@ -183,7 +183,10 @@ def initial(smp: Sample):
         reference=ArArBasic(
             name='REFERENCE', journal='JOURNAL', doi='DOI'
         ),
-        preference=copy.deepcopy(PREFERENCE_RES)
+        preference=copy.deepcopy(PREFERENCE_RES),
+        experiment=ArArBasic(
+            name='', mass_spec='', collectors='', step_num=0
+        ),
     ))
 
     decimal_places = PREFERENCE_RES['decimalPlaces']
@@ -234,7 +237,7 @@ def initial(smp: Sample):
     return smp
 
 
-def initial_plot_styles(sample: Sample, except_attrs=None):
+def initial_plot_styles(smp: Sample, except_attrs=None):
     """
     Initialize plot components styles based on Default Styles. Except attrs is a list containing attrs
     that are not expected to be initialized.
@@ -258,17 +261,26 @@ def initial_plot_styles(sample: Sample, except_attrs=None):
             for k, v in value.items():
                 set_attr(getattr(obj, name), k, v)
 
-    default_styles = copy.deepcopy(samples.DEFAULT_PLOT_STYLES)
+    default_styles = get_default_plot_style(smp)
     for figure_index, figure_attr in default_styles.items():
-        plot = getattr(sample, figure_attr['attr_name'], Plot())
+        plot = getattr(smp, figure_attr['attr_name'], Plot())
         for key, attr in figure_attr.items():
             set_attr(plot, key, attr)
 
 
-def re_set_smp(sample: Sample):
+def get_default_plot_style(smp: Sample):
+    sample_type = smp.Info.sample.type
+    try:
+        age_unit = str(smp.Info.preference['ageUnit']).capitalize()
+    except:
+        age_unit = "Undefined"
+    return copy.deepcopy(samples.DEFAULT_PLOT_STYLES(sample_type, age_unit))
+
+
+def re_set_smp(smp: Sample):
     std = initial(Sample())
-    basic.get_merged_smp(sample, std)
-    return sample
+    basic.get_merged_smp(smp, std)
+    return check_version(smp)
 
 
 def check_version(smp: Sample):
@@ -283,7 +295,28 @@ def check_version(smp: Sample):
 
     """
     if smp.version != samples.VERSION:
-        re_set_smp(smp)
+        std = initial(Sample())
+        basic.get_merged_smp(smp, std)
+
+    # 20250328:  # Experiment info
+    smp.Info.experiment.name = smp.name()
+    smp.Info.experiment.step_num = smp.sequence().size
+
+    # 20250404
+    doNormalize = True
+    v, sv = [], []
+    if smp.Info.sample.type.lower() == "unknown":
+        v, sv = smp.TotalParam[67:69]
+        sv = np.multiply(v, sv) / 100
+    elif smp.Info.sample.type.lower() == "air":
+        v, sv = smp.TotalParam[93:95]
+        sv = np.multiply(v, sv) / 100
+    elif smp.Info.sample.type.lower() == "standard":
+        v, sv = smp.TotalParam[59:61]
+    smp.NormalizeFactor = [
+        [1 if v[0] == each or not doNormalize else v[0] / each for each in v],
+        [0 if v[0] == v[i] or not doNormalize else err.div((v[0], sv[0]), (v[i], sv[i])) for i in range(len(v))]
+    ]
     return smp
 
 
@@ -329,11 +362,8 @@ def from_arr_files(file_path, sample_name: str = ""):
     def renamed_load(file_obj):
         return RenameUnpickler(file_obj).load()
 
-    try:
-        with open(file_path, 'rb') as f:
-            sample = renamed_load(f)
-    except (Exception, BaseException):
-        raise ValueError(f"Fail to open arr file: {file_path}")
+    with open(file_path, 'rb') as f:
+        sample = renamed_load(f)
     # Check arr version
     # recalculation will not be applied automatically
     return check_version(sample)
@@ -353,7 +383,7 @@ def from_calc_files(file_path: str, **kwargs):
     """
     file = calc_file.ArArCalcFile(file_path=file_path, **kwargs).open()
     sample = create_sample_from_df(file.get_content(), file.get_smp_info())
-    return sample
+    return check_version(sample)
 
 
 # create
@@ -372,7 +402,7 @@ def from_full_files(file_path: str, sample_name: str = None):
         sample_name = str(os.path.split(file_path)[-1]).split('.')[0]
     content, sample_info = calc_file.open_full_xls(file_path, sample_name)
     sample = create_sample_from_dict(content=content, smp_info=sample_info)
-    return sample
+    return check_version(sample)
 
 
 # create
@@ -450,4 +480,4 @@ def from_raw_data(raw: RawData, mapping: Optional[List[dict]] = None) -> Sample:
 
     # sample.TotalParam[31] = [raw.get_sequence(row['unknown'], flag='name').datetime for row in mapping]
 
-    return sample
+    return check_version(sample)