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

ararpy/smp/export.py

@@ -22,11 +22,15 @@ from decimal import Decimal
 
 from ..calc import arr, isochron, spectra
 from ..calc.basic import get_random_digits
+from ..calc.plot import get_axis_scale
 from . import basic, sample, consts
 
 Sample = sample.Sample
 Plot = sample.Plot
 
+title_size = 11
+label_size = 11
+
 try:
     from webarar.settings import SETTINGS_ROOT
 except ModuleNotFoundError:
@@ -43,44 +47,55 @@ def to_pdf(file_path: str, figure: str, smp: Sample):
     pdf.save(figure=figure)
 
 
-def get_cv_from_dict(data: dict):
+def get_cv_from_dict(data: dict, **kwargs):
     # create a canvas
-    cv = pm.Canvas(width=17, height=12, unit="cm", show_frame=True, clip_outside_plot_areas=False)
+    cv = pm.Canvas(width=kwargs.get("width", 17), height=kwargs.get("height", 12),
+                   unit="cm", show_frame=False, clip_outside_plot_areas=False)
     # change frame outline style
-    cv.show_frame(color="grey", line_width=0.5)
+    if kwargs.get("show_frame", True):
+        cv.show_frame(color="grey", line_width=0.5)
     axis_num = min([len(data['xAxis']), len(data['yAxis'])])
     # draw axis
     plots = []
     for i in range(axis_num):
         scale = [*data['xAxis'][i]['extent'], *data['yAxis'][i]['extent']]
-        scale = (*scale,)
+        scale = (float(scale[0]), float(scale[1]), float(scale[2]), float(scale[3]))
         # create plot area based on axis scale
-        pt = cv.add_plot_area(name=f"PlotArea{i}", plot_area=(0.15, 0.15, 0.8, 0.8), plot_scale=scale, show_frame=True)
+        plot_area = (kwargs.get("pt_left", 0.15), kwargs.get("pt_bottom", 0.15), kwargs.get("pt_width", 0.8), kwargs.get("pt_height", 0.8))
+        pt = cv.add_plot_area(name=f"PlotArea{i}", plot_area=plot_area, plot_scale=scale, show_frame=True)
         for stick in data['xAxis'][i]['interval']:
-            start = pt.scale_to_points(stick, scale[2])
-            end = pt.scale_to_points(stick, scale[2])
+            start = pt.scale_to_points(float(stick), scale[2])
+            end = pt.scale_to_points(float(stick), scale[2])
             end = (end[0], end[1] - 5)
             if pt.line(start=start, end=end, width=1, line_style="solid", y_clip=False, coordinate="pt", z_index=100):
-                pt.text(x=start[0], y=end[1] - 15, text=f"{stick}", clip=False,
+                pt.text(x=start[0], y=end[1] - 15, text=f"{stick}", clip=False, size=int(data['xAxis'][i]['label_size']),
                         coordinate="pt", h_align="middle", z_index=150)
         for stick in data['yAxis'][i]['interval']:
-            start = pt.scale_to_points(scale[0], stick)
-            end = pt.scale_to_points(scale[0], stick)
+            start = pt.scale_to_points(scale[0], float(stick))
+            end = pt.scale_to_points(scale[0], float(stick))
             end = (end[0] - 5, end[1])
             if pt.line(start=start, end=end, width=1, line_style="solid", x_clip=False, coordinate="pt", z_index=100):
-                pt.text(x=end[0] - 5, y=end[1], text=f"{stick}", clip=False,
+                pt.text(x=end[0] - 5, y=end[1], text=f"{stick}", clip=False, size=int(data['yAxis'][i]['label_size']),
                         coordinate="pt", h_align="right", v_align="center", z_index=150)
         # axis titles
         nloc = pt.scale_to_points(sum(scale[:2]) / 2, scale[2])
-        pt.text(x=nloc[0], y=nloc[1] - 30, text=data['xAxis'][i]['title'], clip=False, coordinate="pt",
-                h_align="middle", v_align="top", z_index=150)
+        pt.text(x=nloc[0], y=nloc[1] - kwargs.get("offset_bottom", 30), text=data['xAxis'][i]['title'], clip=False, coordinate="pt",
+                h_align="middle", v_align="center", z_index=150, size=int(data['xAxis'][i]['title_size']))
         nloc = pt.scale_to_points(scale[0], sum(scale[2:4]) / 2)
-        pt.text(x=nloc[0] - 50, y=nloc[1], text=data['yAxis'][i]['title'], clip=False, coordinate="pt",
-                h_align="middle", v_align="bottom", rotate=90, z_index=150)
+        pt.text(x=nloc[0] - kwargs.get("offset_left", 50), y=nloc[1], text=data['yAxis'][i]['title'], clip=False, coordinate="pt",
+                h_align="middle", v_align="center", rotate=90, z_index=150, size=int(data['yAxis'][i]['title_size']))
         plots.append(pt)
     # draw series
     for se in data['series']:
-        data = se.get('data', [])
+        data = np.array(se.get('data', []), dtype=np.float64)
+        for key, val in se.items():
+            if str(val).isnumeric():
+                se[key] = int(val)
+            else:
+                try:
+                    se[key] = float(val)
+                except (ValueError, TypeError):
+                    pass
         try:
             pt = plots[se.get('axis_index', 0)]
         except IndexError:
@@ -110,12 +125,12 @@ def get_cv_from_dict(data: dict):
     return cv
 
 
-def export_chart_to_pdf(data: dict, filepath: str = "", **kwargs):
+def export_chart_to_pdf(cvs, file_name: str = "", file_path: str = "", **kwargs):
     """
 
     Parameters
     ----------
-    filepath: str
+    file_path: str
     data: dict
         - file_name: string
             file name, like "24WHA0001"
@@ -165,30 +180,70 @@ def export_chart_to_pdf(data: dict, filepath: str = "", **kwargs):
     -------
 
     """
-    title = data.get('file_name', '')
     # write pdf
-    file = pm.NewPDF(filepath=filepath, title=f"{title}", **kwargs)
-    plot_data = data.get('data', [])
-    for index, each in enumerate(plot_data):
-        # rich text tags should follow this priority: color > script > break
-        file.text(
-            page=index, x=50, y=780, line_space=1.2, size=12, base=0, h_align="left",
-            text=f"{each.get('name', '')}"
-        )
-        cv = get_cv_from_dict(each)
-        file.canvas(page=index, base=0, margin_top=5, canvas=cv, unit="cm", h_align="middle")
-        if index + 1 < len(plot_data):
+    show_label = kwargs.get('show_label', False)
+    num_cols = kwargs.get('num_columns', 2)
+    file = pm.NewPDF(filepath=file_path, title=f"{file_name}", **kwargs)
+    page_size = {
+        "a3": (297, 420),
+        "a4": (210, 297),
+        "b5": (176, 250),
+        "a5": (148, 210),
+    }
+    for i in file.get_page_indexes():
+        file.del_obj(i)
+    file.add_page(size=page_size[kwargs.get('page_size', 'a4').lower()], unit='mm')
+    for page_index, page in enumerate(cvs):
+
+        # for x in range(0, 600, 10):
+        #     file.line(page_index, start=(x, 0), end=(x, 900), style='dash', color='grey')
+        # for y in range(0, 900, 10):
+        #     file.line(page_index, start=(0, y), end=(800, y), style='dash', color='grey')
+
+        numbers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N']
+
+        for cv_index, cv in enumerate(page):
+            left = 10 + cv_index % num_cols * cv.width()
+            top = 20 + cv_index // num_cols * cv.height()
+            if show_label:
+                # file.text(page=page_index, x=left + 65, y=810 - top, text=numbers[cv_index])
+                cv._plot_areas[1].text(
+                    x=5, y=95, text=numbers[cv_index],
+                    id=f'text-label-{page_index}-{cv_index}',
+                    name=f'text-label-{page_index}-{cv_index}',
+                    color='black', size=title_size, axis_index=1, h_align='middle', v_align='center'
+                )
+            file.canvas(page=page_index, base=0, margin_left=left, margin_top=top, canvas=cv, unit="pt")
+        if page_index + 1 < len(cvs):
             file.add_page()
 
     # save pdf
     file.save()
 
-    return filepath
+    return file_path
 
 
 def get_plot_data(smp: Sample, diagram: str = 'age spectra', **options):
     """
 
+    Parameters
+    ----------
+    smp
+    diagram
+    options
+
+    Returns
+    -------
+
+    """
+    xAxis, yAxis = get_plot_axis_data(smp, diagram=diagram.lower(), **options)
+    series = get_plot_series_data(smp, diagram=diagram.lower(), xAxis=xAxis, yAxis=yAxis, **options)
+    return {'name': smp.name(), 'xAxis': xAxis, 'yAxis': yAxis, 'series': series}
+
+
+def get_plot_axis_data(smp: Sample, diagram: str = 'age spectra', **options):
+    """
+
     Parameters
     ----------
     smp
@@ -201,80 +256,217 @@ def get_plot_data(smp: Sample, diagram: str = 'age spectra', **options):
 
     """
     if diagram.lower() == "age spectra":
-        xAxis, yAxis, series = _get_plot_data_age_spectra(smp, **options)
+        xAxis, yAxis = _get_plot_data_age_spectra_axis(smp, **options)
     elif diagram.lower() == "inverse isochron":
-        xAxis, yAxis, series = _get_plot_data_inv_isochron(smp, **options)
+        xAxis, yAxis = _get_plot_data_inv_isochron_axis(smp, **options)
     elif "degas spectra" in diagram.lower():
-        xAxis, yAxis, series = _get_plot_data_degas_spectra(smp, diagram_name = diagram.lower(), **options)
+        xAxis, yAxis = _get_plot_data_degas_spectra_axis(smp, diagram_name = diagram.lower(), **options)
     elif "degas curve" in diagram.lower():
-        xAxis, yAxis, series = _get_plot_data_degas_curve(smp, diagram_name = diagram.lower(), **options)
+        xAxis, yAxis = _get_plot_data_degas_curve_axis(smp, diagram_name = diagram.lower(), **options)
     else:
         raise KeyError
+    return xAxis, yAxis
 
-    data = {
-        'name': smp.name(), 'xAxis': xAxis, 'yAxis': yAxis, 'series': series
-    }
 
-    print(data)
+def get_plot_series_data(smp: Sample, diagram: str = 'age spectra', **options):
+    """
 
-    return data
+    Parameters
+    ----------
+    smp
+    diagram
+    color
+    options
+
+    Returns
+    -------
+
+    """
+    if diagram.lower() == "age spectra":
+        series = _get_plot_data_age_spectra_series(smp, **options)
+    elif diagram.lower() == "inverse isochron":
+        series = _get_plot_data_inv_isochron_series(smp, **options)
+    elif "degas spectra" in diagram.lower():
+        series = _get_plot_data_degas_spectra_series(smp, diagram_name=diagram.lower(), **options)
+    elif "degas curve" in diagram.lower():
+        series = _get_plot_data_degas_curve_series(smp, diagram_name=diagram.lower(), **options)
+    else:
+        raise KeyError
+    series.append(_get_additional_text_series(smp.name()))
+    return series
 
 
-def _get_plot_data_age_spectra(smp: sample, **options):
+def _get_additional_text_series(name):
+    return {
+        'type': 'text', 'id': f'text-{name}-{get_random_digits()}',
+        'name': f'text-{name}-{get_random_digits()}', 'color': 'black',
+        'text': "", 'size': title_size,
+        'data': [[50, 50]], 'axis_index': 1,
+        'h_align': "middle", 'v_align': "center",
+    }
+
+
+def _get_plot_data_age_spectra_series(smp: sample, **options):
     color = options.get('color', 'black')
-    xAxis, yAxis, series = [], [], []
+    sigma = options.get('sigma', 1)
+    xAxis = options.get('xAxis', [{}])
+    yAxis = options.get('yAxis', [{}])
+    series = []
     age = smp.ApparentAgeValues[2:4]
     ar = smp.DegasValues[20]
     data = spectra.get_data(*age, ar, cumulative=False)
     series.append({
-        'type': 'series.line', 'id': f'line-{get_random_digits()}', 'name': f'line-{get_random_digits()}',
+        'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
         'color': color, 'fill_color': color, 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
         'data': np.transpose([data[0], data[1]]).tolist(), 'line_caps': 'square',
         'axis_index': 0,
     })
     series.append({
-        'type': 'series.line', 'id': f'line-{get_random_digits()}', 'name': f'line-{get_random_digits()}',
+        'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
         'color': color, 'fill_color': color, 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
         'data': np.transpose([data[0], data[2]]).tolist(), 'line_caps': 'square',
         'axis_index': 0,
     })
     text1 = smp.AgeSpectraPlot.text1
     text2 = smp.AgeSpectraPlot.text2
-    for text in [text1, text2]:
+    for index, text in enumerate([text1, text2]):
+        if not np.isnan(smp.Info.results.age_spectra[index]['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))
+            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,
+                '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}%",
+                'size': title_size,
+                'data': [text.pos],
+                'axis_index': 1,
+                'h_align': "middle",
+                'v_align': "center",
+            })
+    tga = smp.Info.results.age_spectra['TGA']
+    if not np.isnan(tga['age']):
         series.append({
-            'type': 'text', 'id': f'text-{get_random_digits()}', 'name': f'text-{get_random_digits()}',
+            'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}', 'name': f'text-{smp.name()}-{get_random_digits()}',
             'color': color, 'fill_color': color,
-            'text': smp.name() + '<r>' + text.text.replace("\n", "<r>"), 'size': int(text.font_size / 1.5),
-            'data': [text.pos],
+            'text': f"TGA = {tga['age']:.2f} ± {(sigma * tga['s3']):.2f} Ma",
+            'size': title_size,
+            'data': [[50, 3]],
             'axis_index': 1,
+            'h_align': "middle",
+            'v_align': "bottom",
         })
 
+    series.append({
+        'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}',
+        'name': f'text-{smp.name()}-{get_random_digits()}', 'color': color,
+        'text': smp.name(), 'size': title_size,
+        'data': [[50, 95]], 'axis_index': 1,
+        'h_align': "middle", 'v_align': "center",
+    })
+
+    return series
+
+
+def _get_plot_data_age_spectra_axis(smp: sample, **options):
+    color = options.get('color', 'black')
+    xAxis, yAxis = [], []
+    age = smp.ApparentAgeValues[2:4]
+    ar = smp.DegasValues[20]
+    data = spectra.get_data(*age, ar, cumulative=False)
+
+    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_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,
         'title': 'Cumulative <sup>39</sup>Ar Released (%)', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 9,
+        'line_width': 1, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
     })
     xAxis.append({
         'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
         'title': '', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 0,
+        'line_width': 1, 'line_style': 'solid', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
     })
     yAxis.append({
-        'extent': [0, 25], 'interval': [0, 5, 10, 15, 20, 25], 'id': 0, 'show_frame': True,
+        'extent': y_extent, 'interval': y_interval,
+        'id': 0, 'show_frame': True,
         'title': 'Apparent Age (Ma)', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 9,
+        'line_width': 1, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
     })
     yAxis.append({
         'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
         'title': '', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 0,
+        'line_width': 1, 'line_style': 'solid', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
     })
-    return xAxis, yAxis, series
+    return xAxis, yAxis
 
 
-def _get_plot_data_inv_isochron(smp: sample, **options):
+def _get_plot_data_inv_isochron_axis(smp: sample, **options):
     color = options.get('color', 'black')
-    xAxis, yAxis, series = [], [], []
+    xAxis, yAxis = [], []
+    data = np.array(smp.InvIsochronPlot.data)
+    set1 = smp.InvIsochronPlot.set1.data
+    set2 = smp.InvIsochronPlot.set2.data
+    set3 = smp.InvIsochronPlot.set3.data
+
+    low_limit, up_limit, stick_num, inc = get_axis_scale(data[0])
+    x_extent = [low_limit, up_limit]
+    interval = [float("{:g}".format(low_limit + i * inc)) for i in range(stick_num + 1)]
+
+    x_extent = [0, 1]
+    interval = ['0', '0.2', '0.4', '0.6', '0.8', '1', '6', '7', '8']
+
+    xAxis.append({
+        'extent': x_extent,
+        'interval': interval,
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': '<sup>39</sup>Ar<sub>K</sub> / <sup>40</sup>Ar<sup>*</sup>', 'name_location': 'middle',
+    })
+    xAxis.append({
+        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
+        'title': '', 'name_location': 'middle', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
+    })
+
+    low_limit, up_limit, stick_num, inc = get_axis_scale(data[2])
+    y_extent = [low_limit, up_limit]
+    interval = [float("{:g}".format(low_limit + i * inc)) for i in range(stick_num + 1)]
+
+    y_extent = [0, 0.004]
+    interval = ['0', '0.001', '0.002', '0.003', '0.004', '0.005', '0.006', '0.007', '0.008']
+
+    yAxis.append({
+        'extent': y_extent,
+        'interval': interval,
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': '<sup>36</sup>Ar<sub>a</sub> / <sup>40</sup>Ar<sup>*</sup>', 'name_location': 'middle',
+    })
+    yAxis.append({
+        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
+        'title': '', 'name_location': 'middle', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
+    })
+
+    return xAxis, yAxis
+
+
+def _get_plot_data_inv_isochron_series(smp: sample, **options):
+    color = options.get('color', 'black')
+    xAxis = options.get('xAxis', [{}])
+    yAxis = options.get('yAxis', [{}])
+    sigma = options.get('sigma', 1)
+    series = []
     age = smp.ApparentAgeValues[2:4]
     ar = smp.DegasValues[20]
     data = np.array(smp.InvIsochronPlot.data)
@@ -283,68 +475,63 @@ def _get_plot_data_inv_isochron(smp: sample, **options):
     set3 = smp.InvIsochronPlot.set3.data
     # set 1
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{get_random_digits()}', 'name': f'scattter-{get_random_digits()}',
-        'stroke_color': 'red', 'fill_color': 'red', 'myType': 'scatter', 'size': 4, 'line_width': 1,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
+        'stroke_color': 'red', 'fill_color': 'red', 'myType': 'scatter', 'size': 3, 'line_width': 0,
         'data': (data[[0, 2], :][:, set1]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     # set 2
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{get_random_digits()}', 'name': f'scattter-{get_random_digits()}',
-        'stroke_color': 'blue', 'fill_color': 'blue', 'myType': 'scatter', 'size': 4, 'line_width': 1,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
+        'stroke_color': 'blue', 'fill_color': 'blue', 'myType': 'scatter', 'size': 3, 'line_width': 0,
         'data': (data[[0, 2], :][:, set2]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     # set 3
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{get_random_digits()}', 'name': f'scattter-{get_random_digits()}',
-        'stroke_color': 'black', 'fill_color': 'none', 'myType': 'scatter', 'size': 4, 'line_width': 1,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
+        'stroke_color': 'black', 'fill_color': 'white', 'myType': 'scatter', 'size': 3, 'line_width': 0,
         'data': (data[[0, 2], :][:, set3]).transpose().tolist(),
         'axis_index': 0, 'z_index': 0
     })
 
     text1 = smp.InvIsochronPlot.text1
     text2 = smp.InvIsochronPlot.text2
+    for index, text in enumerate([text1, text2]):
+        if not np.isnan(smp.Info.results.isochron['figure_3'][index]['age']):
+            isochron_data = [
+                            (float(xAxis[0]['extent'][0]), float(xAxis[0]['extent'][0]) * smp.Info.results.isochron['figure_3'][index]['m1'] + smp.Info.results.isochron['figure_3'][index]['k']),
+                            (float(xAxis[0]['extent'][1]), float(xAxis[0]['extent'][1]) * smp.Info.results.isochron['figure_3'][index]['m1'] + smp.Info.results.isochron['figure_3'][index]['k']),
+            ]
+            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], 'fill_color': ['red', 'blue'][index],
+                'line_width': 1.5, 'line_style': 'solid',
+                'data': isochron_data,
+                '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"IIA = {smp.Info.results.isochron['figure_3'][index]['age']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['s3']):.2f} Ma<r>"
+                        f"[<sup>40</sup>Ar/<sup>36</sup>Ar]<sub>i</sub> = {smp.Info.results.isochron['figure_3'][index]['initial']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['sinitial']):.2f}<r>"
+                        f"MSWD = {smp.Info.results.isochron['figure_3'][index]['MSWD']:.2f}, r<sup>2</sup> = {smp.Info.results.isochron['figure_3'][index]['R2']:.4f}<r>",
+                'size': title_size,
+                'data': [text.pos],
+                'axis_index': 1,
+                'h_align': "middle",
+                'v_align': "center",
+            })
 
     series.append({
-        'type': 'text', 'id': f'text-{get_random_digits()}', 'name': f'text-{get_random_digits()}',
-        'color': 'red', 'fill_color': 'red',
-        'text': smp.name() + '<r>' + text1.text.replace("\n", "<r>"), 'size': int(text1.font_size / 1.5),
-        'data': [text1.pos],
-        'axis_index': 1,
-    })
-    series.append({
-        'type': 'text', 'id': f'text-{get_random_digits()}', 'name': f'text-{get_random_digits()}',
-        'color': 'blue', 'fill_color': 'blue',
-        'text': smp.name() + '<r>' + text2.text.replace("\n", "<r>"), 'size': int(text2.font_size / 1.5),
-        'data': [text2.pos],
-        'axis_index': 1,
+        'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}',
+        'name': f'text-{smp.name()}-{get_random_digits()}', 'color': color,
+        'text': smp.name(), 'size': title_size,
+        'data': [[50, 95]], 'axis_index': 1,
+        'h_align': "middle", 'v_align': "center",
     })
 
-    xaxis = smp.InvIsochronPlot.xaxis
-    yaxis = smp.InvIsochronPlot.yaxis
-
-    xAxis.append({
-        'extent': [float(xaxis.min), float(xaxis.max)],
-        'interval': [float("{:g}".format(float(xaxis.min) + i * float(xaxis.interval))) for i in range(int(xaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
-        'title': 'XXXX', 'name_location': 'middle',
-    })
-    xAxis.append({
-        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
-        'title': '', 'name_location': 'middle', 'z_index': 0,
-    })
-    yAxis.append({
-        'extent': [float(yaxis.min), float(yaxis.max)],
-        'interval': [float("{:g}".format(float(yaxis.min) + i * float(yaxis.interval))) for i in range(int(yaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
-        'title': 'YYYY', 'name_location': 'middle',
-    })
-    yAxis.append({
-        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
-        'title': '', 'name_location': 'middle', 'z_index': 0,
-    })
-    return xAxis, yAxis, series
+    return series
 
 
 def _get_plot_data_degas_pattern(smp: sample, **options):
@@ -359,7 +546,7 @@ def _get_plot_data_degas_pattern(smp: sample, **options):
     data = np.array([x, y])
     # set 1
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{get_random_digits()}', 'name': f'scattter-{get_random_digits()}',
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
         'stroke_color': color, 'fill_color': 'white', 'myType': 'scatter', 'size': 4, 'line_width': 1,
         'data': data.transpose().tolist(), 'axis_index': 0, 'z_index': 99
     })
@@ -379,23 +566,57 @@ def _get_plot_data_degas_pattern(smp: sample, **options):
     xAxis.append({
         'extent': [float(xaxis.min), float(xaxis.max)],
         'interval': [float("{:g}".format(float(xaxis.min) + i * float(xaxis.interval))) for i in range(int(xaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
         'title': 'XXXX', 'name_location': 'middle',
     })
     yAxis.append({
         'extent': [float(yaxis.min), float(yaxis.max)],
         'interval': [float("{:g}".format(float(yaxis.min) + i * float(yaxis.interval))) for i in range(int(yaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
         'title': 'YYYY', 'name_location': 'middle',
     })
     return xAxis, yAxis, series
 
 
-def _get_plot_data_degas_spectra(smp: sample, **options):
+def _get_plot_data_degas_spectra_axis(smp: sample, **options):
     name = options.get('diagram_name', '39Ar')
     color = options.get('color', 'black')
     plot = smp.DegasPatternPlot
-    xAxis, yAxis, series = [], [], []
+    xAxis, yAxis = [], []
+
+    xaxis = plot.xaxis
+    yaxis = plot.yaxis
+    xaxis.min = 0
+    xaxis.max = 100
+    xaxis.interval = 20
+    xaxis.split_number = 5
+    yaxis.min = 0
+    yaxis.max = 20
+    yaxis.interval = 5
+    yaxis.split_number = 4
+
+    xAxis.append({
+        'extent': [float(xaxis.min), float(xaxis.max)],
+        'interval': [float("{:g}".format(float(xaxis.min) + i * float(xaxis.interval))) for i in range(int(xaxis.split_number) + 1)],
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': 'Steps [n]', 'name_location': 'middle',
+    })
+    yAxis.append({
+        'extent': [float(yaxis.min), float(yaxis.max)],
+        'interval': [float("{:g}".format(float(yaxis.min) + i * float(yaxis.interval))) for i in range(int(yaxis.split_number) + 1)],
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': 'Argon Released [%]', 'name_location': 'middle',
+    })
+    return xAxis, yAxis
+
+
+def _get_plot_data_degas_spectra_series(smp: sample, **options):
+    name = options.get('diagram_name', '39Ar')
+    color = options.get('color', 'black')
+    plot = smp.DegasPatternPlot
+    xAxis = options.get('xAxis', [{}])
+    yAxis = options.get('yAxis', [{}])
+    series = []
     nindex = {"40": 24, "39": 20, "38": 10, "37": 8, "36": 0}
     if name[:2] in list(nindex.keys()):
         ar = np.array(smp.DegasValues[nindex[name[:2]]], dtype=np.float64)  # 20-21 Ar39
@@ -415,45 +636,42 @@ def _get_plot_data_degas_spectra(smp: sample, **options):
     height = [ar[i] / sum(ar) * 100 for i in range(len(ar))]
     data = np.array([x, y, width, height])
 
-    xaxis = plot.xaxis
-    yaxis = plot.yaxis
-
-    xaxis.min = 0
-    xaxis.max = 100
-    xaxis.interval = 20
-    xaxis.split_number = 5
-    yaxis.min = 0
-    yaxis.max = 20
-    yaxis.interval = 5
-    yaxis.split_number = 4
-
     # set 1
     series.append({
-        'type': 'rect', 'id': f'rect-{get_random_digits()}', 'name': f'rect-{get_random_digits()}',
+        'type': 'rect', 'id': f'rect-{smp.name()}-{get_random_digits()}', 'name': f'rect-{smp.name()}-{get_random_digits()}',
         'color': color, 'myType': 'rect', 'line_width': 1,
         'data': data.transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
 
+    return series
+
+
+def _get_plot_data_degas_curve_axis(smp: sample, **options):
+    name = options.get('diagram_name', '39Ar')
+    color = options.get('color', 'black')
+    xAxis, yAxis = [], []
     xAxis.append({
-        'extent': [float(xaxis.min), float(xaxis.max)],
-        'interval': [float("{:g}".format(float(xaxis.min) + i * float(xaxis.interval))) for i in range(int(xaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
+        'extent': [0, 100],
+        'interval': [0, 20, 40, 60, 80, 100],
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
         'title': 'Steps [n]', 'name_location': 'middle',
     })
     yAxis.append({
-        'extent': [float(yaxis.min), float(yaxis.max)],
-        'interval': [float("{:g}".format(float(yaxis.min) + i * float(yaxis.interval))) for i in range(int(yaxis.split_number) + 1)],
-        'id': 0, 'show_frame': True, 'z_index': 9,
-        'title': 'Argon Released [%]', 'name_location': 'middle',
+        'extent': [0, 100],
+        'interval': [0, 20, 40, 60, 80, 100],
+        'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': 'Argon [%]', 'name_location': 'middle',
     })
-    return xAxis, yAxis, series
+    return xAxis, yAxis
 
 
-def _get_plot_data_degas_curve(smp: sample, **options):
+def _get_plot_data_degas_curve_series(smp: sample, **options):
     name = options.get('diagram_name', '39Ar')
     color = options.get('color', 'black')
-    xAxis, yAxis, series = [], [], []
+    xAxis = options.get('xAxis', [{}])
+    yAxis = options.get('yAxis', [{}])
+    series = []
     nindex = {"40": 24, "39": 20, "38": 10, "37": 8, "36": 0}
     if name[:2] in list(nindex.keys()):
         ar = np.array(smp.DegasValues[nindex[name[:2]]], dtype=np.float64)  # 20-21 Ar39
@@ -477,31 +695,19 @@ def _get_plot_data_degas_curve(smp: sample, **options):
 
     # line
     series.append({
-        'type': 'line', 'id': f'line-{get_random_digits()}', 'name': f'line-{get_random_digits()}',
+        'type': 'line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
         'color': color, 'myType': 'line', 'line_width': 1, 'line_style': 'solid',
         'data': np.array([x, released]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     series.append({
-        'type': 'line', 'id': f'line-{get_random_digits()}', 'name': f'line-{get_random_digits()}',
+        'type': 'line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
         'color': color, 'myType': 'line', 'line_width': 1, 'line_style': 'solid',
         'data': np.array([x, remained]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
 
-    xAxis.append({
-        'extent': [0, 100],
-        'interval': [0, 20, 40, 60, 80, 100],
-        'id': 0, 'show_frame': True, 'z_index': 9,
-        'title': 'Steps [n]', 'name_location': 'middle',
-    })
-    yAxis.append({
-        'extent': [0, 100],
-        'interval': [0, 20, 40, 60, 80, 100],
-        'id': 0, 'show_frame': True, 'z_index': 9,
-        'title': 'Argon [%]', 'name_location': 'middle',
-    })
-    return xAxis, yAxis, series
+    return series
 
 
 class ExcelTemplate:
@@ -585,31 +791,42 @@ class WritingWorkbook:
         ]
         # writing header
         sht_reference.write_row(row=start_row - 3, col=0, data=reference_header, cell_format=style)
+
+        # total rows, sequence number
+        total_rows = len(self.sample.SequenceName)
+
         # Data for age spectra
-        spectra_data = arr.transpose(self.sample.AgeSpectraPlot.data)
-        spectra_set1_data = arr.transpose(self.sample.AgeSpectraPlot.set1.data) or [[]] * 3
-        spectra_set2_data = arr.transpose(self.sample.AgeSpectraPlot.set2.data) 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)
-        sht_reference.write_column(f"D{start_row}", spectra_set1_data[0], style)
-        sht_reference.write_column(f"E{start_row}", spectra_set1_data[1], style)
-        sht_reference.write_column(f"F{start_row}", spectra_set1_data[2], style)
-        sht_reference.write_column(f"G{start_row}", spectra_set2_data[0], style)
-        sht_reference.write_column(f"H{start_row}", spectra_set2_data[1], style)
-        sht_reference.write_column(f"I{start_row}", spectra_set2_data[2], style)
-        sht_reference.write_column(f"J{start_row}", [], style)
-        sht_reference.write_column(f"K{start_row}", [], style)
+        try:
+            spectra_data = arr.transpose(self.sample.AgeSpectraPlot.data)
+            spectra_set1_data = arr.transpose(self.sample.AgeSpectraPlot.set1.data) or [[]] * 3
+            spectra_set2_data = arr.transpose(self.sample.AgeSpectraPlot.set2.data) 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)
+            sht_reference.write_column(f"D{start_row}", spectra_set1_data[0], style)
+            sht_reference.write_column(f"E{start_row}", spectra_set1_data[1], style)
+            sht_reference.write_column(f"F{start_row}", spectra_set1_data[2], style)
+            sht_reference.write_column(f"G{start_row}", spectra_set2_data[0], style)
+            sht_reference.write_column(f"H{start_row}", spectra_set2_data[1], style)
+            sht_reference.write_column(f"I{start_row}", spectra_set2_data[2], style)
+            sht_reference.write_column(f"J{start_row}", [], style)
+            sht_reference.write_column(f"K{start_row}", [], style)
+        except IndexError:
+            pass
+
         # Data for normal isochron
-        set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
-            self.sample.NorIsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
-            self.sample.UnselectedSequence)
-        sht_reference.write_column(f"O{start_row}", set1_data[0], style)
-        sht_reference.write_column(f"P{start_row}", set1_data[2], style)
-        sht_reference.write_column(f"Q{start_row}", set2_data[0], style)
-        sht_reference.write_column(f"R{start_row}", set2_data[2], style)
-        sht_reference.write_column(f"S{start_row}", set3_data[0], style)
-        sht_reference.write_column(f"T{start_row}", set3_data[2], style)
+        try:
+            set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
+                self.sample.NorIsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
+                self.sample.UnselectedSequence)
+            sht_reference.write_column(f"O{start_row}", set1_data[0], style)
+            sht_reference.write_column(f"P{start_row}", set1_data[2], style)
+            sht_reference.write_column(f"Q{start_row}", set2_data[0], style)
+            sht_reference.write_column(f"R{start_row}", set2_data[2], style)
+            sht_reference.write_column(f"S{start_row}", set3_data[0], style)
+            sht_reference.write_column(f"T{start_row}", set3_data[2], style)
+        except IndexError:
+            pass
         try:
             sht_reference.write_column(f"U{start_row}", self.sample.NorIsochronPlot.line1.data[0], style)
         except IndexError:
@@ -626,16 +843,20 @@ class WritingWorkbook:
             sht_reference.write_column(f"X{start_row}", self.sample.NorIsochronPlot.line2.data[1], style)
         except IndexError:
             pass
+
         # Data for inverse isochron
-        set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
-            self.sample.InvIsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
-            self.sample.UnselectedSequence)
-        sht_reference.write_column(f"Y{start_row}", set1_data[0], style)
-        sht_reference.write_column(f"Z{start_row}", set1_data[2], style)
-        sht_reference.write_column(f"AA{start_row}", set2_data[0], style)
-        sht_reference.write_column(f"AB{start_row}", set2_data[2], style)
-        sht_reference.write_column(f"AC{start_row}", set3_data[0], style)
-        sht_reference.write_column(f"AD{start_row}", set3_data[2], style)
+        try:
+            set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
+                self.sample.InvIsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
+                self.sample.UnselectedSequence)
+            sht_reference.write_column(f"Y{start_row}", set1_data[0], style)
+            sht_reference.write_column(f"Z{start_row}", set1_data[2], style)
+            sht_reference.write_column(f"AA{start_row}", set2_data[0], style)
+            sht_reference.write_column(f"AB{start_row}", set2_data[2], style)
+            sht_reference.write_column(f"AC{start_row}", set3_data[0], style)
+            sht_reference.write_column(f"AD{start_row}", set3_data[2], style)
+        except IndexError:
+            pass
         try:
             sht_reference.write_column(f"AE{start_row}", self.sample.InvIsochronPlot.line1.data[0], style)
         except IndexError:
@@ -652,16 +873,20 @@ class WritingWorkbook:
             sht_reference.write_column(f"AH{start_row}", self.sample.InvIsochronPlot.line2.data[1], style)
         except IndexError:
             pass
+
         # Data for Cl 1 isochron
-        set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
-            self.sample.KClAr1IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
-            self.sample.UnselectedSequence)
-        sht_reference.write_column(f"AI{start_row}", set1_data[0], style)
-        sht_reference.write_column(f"AJ{start_row}", set1_data[2], style)
-        sht_reference.write_column(f"AK{start_row}", set2_data[0], style)
-        sht_reference.write_column(f"AL{start_row}", set2_data[2], style)
-        sht_reference.write_column(f"AM{start_row}", set3_data[0], style)
-        sht_reference.write_column(f"AN{start_row}", set3_data[2], style)
+        try:
+            set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
+                self.sample.KClAr1IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
+                self.sample.UnselectedSequence)
+            sht_reference.write_column(f"AI{start_row}", set1_data[0], style)
+            sht_reference.write_column(f"AJ{start_row}", set1_data[2], style)
+            sht_reference.write_column(f"AK{start_row}", set2_data[0], style)
+            sht_reference.write_column(f"AL{start_row}", set2_data[2], style)
+            sht_reference.write_column(f"AM{start_row}", set3_data[0], style)
+            sht_reference.write_column(f"AN{start_row}", set3_data[2], style)
+        except IndexError:
+            pass
         try:
             sht_reference.write_column(f"AO{start_row}", self.sample.KClAr1IsochronPlot.line1.data[0], style)
         except IndexError:
@@ -678,16 +903,20 @@ class WritingWorkbook:
             sht_reference.write_column(f"AR{start_row}", self.sample.KClAr1IsochronPlot.line2.data[1], style)
         except IndexError:
             pass
+
         # Data for Cl 2 isochron
-        set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
-            self.sample.KClAr2IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
-            self.sample.UnselectedSequence)
-        sht_reference.write_column(f"AS{start_row}", set1_data[0], style)
-        sht_reference.write_column(f"AT{start_row}", set1_data[2], style)
-        sht_reference.write_column(f"AU{start_row}", set2_data[0], style)
-        sht_reference.write_column(f"AV{start_row}", set2_data[2], style)
-        sht_reference.write_column(f"AW{start_row}", set3_data[0], style)
-        sht_reference.write_column(f"AX{start_row}", set3_data[2], style)
+        try:
+            set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
+                self.sample.KClAr2IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
+                self.sample.UnselectedSequence)
+            sht_reference.write_column(f"AS{start_row}", set1_data[0], style)
+            sht_reference.write_column(f"AT{start_row}", set1_data[2], style)
+            sht_reference.write_column(f"AU{start_row}", set2_data[0], style)
+            sht_reference.write_column(f"AV{start_row}", set2_data[2], style)
+            sht_reference.write_column(f"AW{start_row}", set3_data[0], style)
+            sht_reference.write_column(f"AX{start_row}", set3_data[2], style)
+        except IndexError:
+            pass
         try:
             sht_reference.write_column(f"AY{start_row}", self.sample.KClAr2IsochronPlot.line1.data[0], style)
         except IndexError:
@@ -704,16 +933,20 @@ class WritingWorkbook:
             sht_reference.write_column(f"BB{start_row}", self.sample.KClAr2IsochronPlot.line2.data[1], style)
         except IndexError:
             pass
+
         # Data for Cl 3 isochron
-        set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
-            self.sample.KClAr3IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
-            self.sample.UnselectedSequence)
-        sht_reference.write_column(f"BC{start_row}", set1_data[0], style)
-        sht_reference.write_column(f"BD{start_row}", set1_data[2], style)
-        sht_reference.write_column(f"BE{start_row}", set2_data[0], style)
-        sht_reference.write_column(f"BF{start_row}", set2_data[2], style)
-        sht_reference.write_column(f"BG{start_row}", set3_data[0], style)
-        sht_reference.write_column(f"BH{start_row}", set3_data[2], style)
+        try:
+            set_data = [set1_data, set2_data, set3_data] = isochron.get_set_data(
+                self.sample.KClAr3IsochronPlot.data, self.sample.SelectedSequence1, self.sample.SelectedSequence2,
+                self.sample.UnselectedSequence)
+            sht_reference.write_column(f"BC{start_row}", set1_data[0], style)
+            sht_reference.write_column(f"BD{start_row}", set1_data[2], style)
+            sht_reference.write_column(f"BE{start_row}", set2_data[0], style)
+            sht_reference.write_column(f"BF{start_row}", set2_data[2], style)
+            sht_reference.write_column(f"BG{start_row}", set3_data[0], style)
+            sht_reference.write_column(f"BH{start_row}", set3_data[2], style)
+        except IndexError:
+            pass
         try:
             sht_reference.write_column(f"BI{start_row}", self.sample.KClAr3IsochronPlot.line1.data[0], style)
         except IndexError:
@@ -730,19 +963,23 @@ class WritingWorkbook:
             sht_reference.write_column(f"BL{start_row}", self.sample.KClAr3IsochronPlot.line2.data[1], style)
         except IndexError:
             pass
+
         # Data for degas pattern
-        degas_data = self.sample.DegasPatternPlot.data
-        sht_reference.write_column(f"BM{start_row}", degas_data[0], style)
-        sht_reference.write_column(f"BN{start_row}", degas_data[1], style)
-        sht_reference.write_column(f"BO{start_row}", degas_data[2], style)
-        sht_reference.write_column(f"BP{start_row}", degas_data[3], style)
-        sht_reference.write_column(f"BQ{start_row}", degas_data[4], style)
-        sht_reference.write_column(f"BR{start_row}", degas_data[5], style)
-        sht_reference.write_column(f"BS{start_row}", degas_data[6], style)
-        sht_reference.write_column(f"BT{start_row}", degas_data[7], style)
-        sht_reference.write_column(f"BU{start_row}", degas_data[8], style)
-        sht_reference.write_column(f"BV{start_row}", degas_data[9], style)
-        sht_reference.write_column(f"BW{start_row}", [i+1 for i in range(len(self.sample.SequenceName))], style)
+        try:
+            degas_data = self.sample.DegasPatternPlot.data
+            sht_reference.write_column(f"BM{start_row}", degas_data[0], style)
+            sht_reference.write_column(f"BN{start_row}", degas_data[1], style)
+            sht_reference.write_column(f"BO{start_row}", degas_data[2], style)
+            sht_reference.write_column(f"BP{start_row}", degas_data[3], style)
+            sht_reference.write_column(f"BQ{start_row}", degas_data[4], style)
+            sht_reference.write_column(f"BR{start_row}", degas_data[5], style)
+            sht_reference.write_column(f"BS{start_row}", degas_data[6], style)
+            sht_reference.write_column(f"BT{start_row}", degas_data[7], style)
+            sht_reference.write_column(f"BU{start_row}", degas_data[8], style)
+            sht_reference.write_column(f"BV{start_row}", degas_data[9], style)
+            sht_reference.write_column(f"BW{start_row}", [i+1 for i in range(len(self.sample.SequenceName))], style)
+        except IndexError:
+            pass
 
         sht_result = xls.add_worksheet('Results')
         title_style = xls.add_format({
@@ -847,165 +1084,17 @@ class WritingWorkbook:
                     continue
 
         for sht_name, [prop_name, sht_type, row, col, _, smp_attr_name, header_name] in self.template.sheet():
-            if sht_type == "table":
-                data = arr.transpose(getattr(self.sample, smp_attr_name, None).data)
-                sht = xls.add_worksheet(sht_name)
-                sht.hide_gridlines(2)  # 0 = show grids, 1 = hide print grid, else = hide print and screen grids
-                sht.hide()  # default hidden table sheet
-                sht.set_column(0, len(data), width=12)  # column width
-                header = getattr(sample, header_name)
-                sht.write_row(row=row - 1, col=col, data=header, cell_format=style)
-                for each_col in data:
-                    res = sht.write_column(row=row, col=col, data=each_col, cell_format=style)
-                    if res:
-                        xls.close()
-                        return None
-                    col += 1
-            elif sht_type == "chart":
-                sht = xls.add_chartsheet(sht_name)
-                sht.set_paper(1)  # US letter = 1, A4 = 9, letter is more rectangular
-                num_unselected = len(self.sample.UnselectedSequence)
-                num_set1 = len(self.sample.SelectedSequence1)
-                num_set2 = len(self.sample.SelectedSequence2)
-                if "spectra" in prop_name.lower():
-                    figure = self.sample.AgeSpectraPlot
-                    data_area = [
-                        # Spectra lines
-                        f"A{start_row}:A{len(spectra_data[0]) + start_row - 1}",
-                        f"B{start_row}:B{len(spectra_data[0]) + start_row - 1}",
-                        f"C{start_row}:C{len(spectra_data[0]) + start_row - 1}",
-                        # set 1
-                        f"D{start_row}:D{len(spectra_data[0]) + start_row - 1}",
-                        f"E{start_row}:E{len(spectra_data[0]) + start_row - 1}",
-                        f"F{start_row}:F{len(spectra_data[0]) + start_row - 1}",
-                        # set 2
-                        f"G{start_row}:G{len(spectra_data[0]) + start_row - 1}",
-                        f"H{start_row}:H{len(spectra_data[0]) + start_row - 1}",
-                        f"I{start_row}:I{len(spectra_data[0]) + start_row - 1}",
-                    ]
-                    axis_range = [figure.xaxis.min, figure.xaxis.max, figure.yaxis.min, figure.yaxis.max]
-                    self.get_chart_age_spectra(xls, sht, data_area, axis_range)
-                elif "normal_isochron" in prop_name.lower():
-                    data_area = [
-                        f"O{start_row}:O{num_set1 + start_row - 1}", f"P{start_row}:P{num_set1 + start_row - 1}",
-                        f"Q{start_row}:Q{num_set2 + start_row - 1}", f"R{start_row}:R{num_set2 + start_row - 1}",
-                        f"S{start_row}:S{num_unselected + start_row - 1}",
-                        f"T{start_row}:T{num_unselected + start_row - 1}",
-                        f"U{start_row}:V{start_row}", f"U{start_row + 1}:V{start_row + 1}",
-                        f"W{start_row}:X{start_row}", f"W{start_row + 1}:X{start_row + 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_2').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_2').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_2').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_2').yaxis.max,
-                    ]
-                    self.get_chart_isochron(
-                        xls, sht, data_area, axis_range, title_name="Normal Isochron",
-                        x_axis_name=f"{consts.sup_39}Ar / {consts.sup_36}Ar",
-                        y_axis_name=f"{consts.sup_40}Ar / {consts.sup_36}Ar")
-                elif "inverse_isochron" in prop_name.lower():
-                    data_area = [
-                        f"Y{start_row}:Y{num_set1 + start_row - 1}", f"Z{start_row}:Z{num_set1 + start_row - 1}",
-                        f"AA{start_row}:AA{num_set2 + start_row - 1}", f"AB{start_row}:AB{num_set2 + start_row - 1}",
-                        f"AC{start_row}:AC{num_unselected + start_row - 1}",
-                        f"AD{start_row}:AD{num_unselected + start_row - 1}",
-                        f"AE{start_row}:AF{start_row}", f"AE{start_row + 1}:AF{start_row + 1}",
-                        f"AG{start_row}:AH{start_row}", f"AG{start_row + 1}:AH{start_row + 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_3').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_3').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_3').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_3').yaxis.max,
-                    ]
-                    self.get_chart_isochron(
-                        xls, sht, data_area, axis_range, title_name="Inverse Isochron",
-                        x_axis_name=f"{consts.sup_39}Ar / {consts.sup_40}Ar",
-                        y_axis_name=f"{consts.sup_36}Ar / {consts.sup_40}Ar")
-                elif "k-cl-ar_1_isochron" in prop_name.lower():
-                    data_area = [
-                        f"AI{start_row}:AI{num_set1 + start_row - 1}", f"AJ{start_row}:AJ{num_set1 + start_row - 1}",
-                        f"AK{start_row}:AK{num_set2 + start_row - 1}", f"AL{start_row}:AL{num_set2 + start_row - 1}",
-                        f"AM{start_row}:AM{num_unselected + start_row - 1}",
-                        f"AN{start_row}:AN{num_unselected + start_row - 1}",
-                        f"AO{start_row}:AP{start_row}", f"AO{start_row + 1}:AP{start_row + 1}",
-                        f"AQ{start_row}:AR{start_row}", f"AQ{start_row + 1}:AR{start_row + 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_4').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_4').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_4').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_4').yaxis.max,
-                    ]
-                    self.get_chart_isochron(
-                        xls, sht, data_area, axis_range, title_name="K-Cl-Ar 1 Isochron",
-                        x_axis_name=f"{consts.sup_39}Ar / {consts.sup_38}Ar",
-                        y_axis_name=f"{consts.sup_40}Ar / {consts.sup_38}Ar")
-                elif "k-cl-ar_2_isochron" in prop_name.lower():
-                    data_area = [
-                        f"AS{start_row}:AS{num_set1 + start_row - 1}", f"AT{start_row}:AT{num_set1 + start_row - 1}",
-                        f"AU{start_row}:AU{num_set2 + start_row - 1}", f"AV{start_row}:AV{num_set2 + start_row - 1}",
-                        f"AW{start_row}:AW{num_unselected + start_row - 1}",
-                        f"AX{start_row}:AX{num_unselected + start_row - 1}",
-                        f"AY{start_row}:AZ{start_row}", f"AY{start_row + 1}:AZ{start_row + 1}",
-                        f"BA{start_row}:BB{start_row}", f"BA{start_row + 1}:BB{start_row + 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_5').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_5').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_5').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_5').yaxis.max,
-                    ]
-                    self.get_chart_isochron(
-                        xls, sht, data_area, axis_range, title_name="K-Cl-Ar 2 Isochron",
-                        x_axis_name=f"{consts.sup_39}Ar / {consts.sup_40}Ar",
-                        y_axis_name=f"{consts.sup_38}Ar / {consts.sup_40}Ar")
-                elif "k-cl-ar_3_isochron" in prop_name.lower():
-                    data_area = [
-                        f"BC{start_row}:BC{num_set1 + start_row - 1}", f"BD{start_row}:BD{num_set1 + start_row - 1}",
-                        f"BE{start_row}:BE{num_set2 + start_row - 1}", f"BF{start_row}:BF{num_set2 + start_row - 1}",
-                        f"BG{start_row}:BG{num_unselected + start_row - 1}",
-                        f"BH{start_row}:BH{num_unselected + start_row - 1}",
-                        f"BI{start_row}:BJ{start_row}", f"BI{start_row + 1}:BJ{start_row + 1}",
-                        f"BK{start_row}:BL{start_row}", f"BK{start_row + 1}:BL{start_row + 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_6').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_6').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_6').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_6').yaxis.max,
-                    ]
-                    self.get_chart_isochron(
-                        xls, sht, data_area, axis_range, title_name="K-Cl-Ar 3 Isochron",
-                        x_axis_name=f"{consts.sup_38}Ar / {consts.sup_39}Ar",
-                        y_axis_name=f"{consts.sup_40}Ar / {consts.sup_39}Ar")
-                elif "degas_pattern" in prop_name.lower():
-                    data_area = [
-                        f"BM{start_row}:BM{len(degas_data[0]) + start_row - 1}",
-                        f"BN{start_row}:BN{len(degas_data[1]) + start_row - 1}",
-                        f"BO{start_row}:BO{len(degas_data[2]) + start_row - 1}",
-                        f"BP{start_row}:BP{len(degas_data[3]) + start_row - 1}",
-                        f"BQ{start_row}:BQ{len(degas_data[4]) + start_row - 1}",
-                        f"BR{start_row}:BR{len(degas_data[5]) + start_row - 1}",
-                        f"BS{start_row}:BS{len(degas_data[6]) + start_row - 1}",
-                        f"BT{start_row}:BT{len(degas_data[7]) + start_row - 1}",
-                        f"BU{start_row}:BU{len(degas_data[8]) + start_row - 1}",
-                        f"BV{start_row}:BV{len(degas_data[9]) + start_row - 1}",
-                        f"BW{start_row}:BW{len(degas_data[9]) + start_row - 1}",
-                    ]
-                    axis_range = [
-                        basic.get_component_byid(self.sample, 'figure_8').xaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_8').xaxis.max,
-                        basic.get_component_byid(self.sample, 'figure_8').yaxis.min,
-                        basic.get_component_byid(self.sample, 'figure_8').yaxis.max,
-                    ]
-                    self.get_chart_degas_pattern(
-                        xls, sht, data_area, axis_range,
-                        title_name="Degas Pattern", x_axis_name=f"Sequence",
-                        y_axis_name=f"Argon Isotopes (%)")
-            else:
-                xls.close()
+            try:
+                if sht_type == "table":
+                    self.write_sht_table(sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name,
+                                         style, xls)
+                elif sht_type == "chart":
+                    self.write_sht_chart(sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name,
+                                         style, xls, start_row, total_rows)
+                else:
+                    raise ValueError
+            except (BaseException, Exception):
+                print(traceback.format_exc())
                 return None
         xls.get_worksheet_by_name("Reference").hide()
         xls.get_worksheet_by_name("Isochrons").hidden = 0  # unhiden isochrons worksheet
@@ -1014,6 +1103,163 @@ class WritingWorkbook:
         print('导出完毕，文件路径:%s' % self.filepath)
         return True
 
+    def write_sht_table(self, sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name, style, xls):
+        sht = xls.add_worksheet(sht_name)
+        data = arr.transpose(getattr(self.sample, smp_attr_name, None).data)
+        sht.hide_gridlines(2)  # 0 = show grids, 1 = hide print grid, else = hide print and screen grids
+        sht.hide()  # default hidden table sheet
+        sht.set_column(0, len(data), width=12)  # column width
+        header = getattr(sample, header_name)
+        sht.write_row(row=row - 1, col=col, data=header, cell_format=style)
+        for each_col in data:
+            res = sht.write_column(row=row, col=col, data=each_col, cell_format=style)
+            if res:
+                raise ValueError(res)
+            col += 1
+
+    def write_sht_chart(self, sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name, style, xls, start_row, total_rows):
+        sht = xls.add_chartsheet(sht_name)
+        sht.set_paper(1)  # US letter = 1, A4 = 9, letter is more rectangular
+        num_unselected = len(self.sample.UnselectedSequence)
+        num_set1 = len(self.sample.SelectedSequence1)
+        num_set2 = len(self.sample.SelectedSequence2)
+        if "spectra" in prop_name.lower():
+            figure = self.sample.AgeSpectraPlot
+            data_area = [
+                # Spectra lines
+                f"A{start_row}:A{total_rows + start_row - 1}",
+                f"B{start_row}:B{total_rows + start_row - 1}",
+                f"C{start_row}:C{total_rows + start_row - 1}",
+                # set 1
+                f"D{start_row}:D{total_rows + start_row - 1}",
+                f"E{start_row}:E{total_rows + start_row - 1}",
+                f"F{start_row}:F{total_rows + start_row - 1}",
+                # set 2
+                f"G{start_row}:G{total_rows + start_row - 1}",
+                f"H{start_row}:H{total_rows + start_row - 1}",
+                f"I{start_row}:I{total_rows + start_row - 1}",
+            ]
+            axis_range = [figure.xaxis.min, figure.xaxis.max, figure.yaxis.min, figure.yaxis.max]
+            self.get_chart_age_spectra(xls, sht, data_area, axis_range)
+        elif "normal_isochron" in prop_name.lower():
+            data_area = [
+                f"O{start_row}:O{num_set1 + start_row - 1}", f"P{start_row}:P{num_set1 + start_row - 1}",
+                f"Q{start_row}:Q{num_set2 + start_row - 1}", f"R{start_row}:R{num_set2 + start_row - 1}",
+                f"S{start_row}:S{num_unselected + start_row - 1}",
+                f"T{start_row}:T{num_unselected + start_row - 1}",
+                f"U{start_row}:V{start_row}", f"U{start_row + 1}:V{start_row + 1}",
+                f"W{start_row}:X{start_row}", f"W{start_row + 1}:X{start_row + 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_2').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_2').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_2').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_2').yaxis.max,
+            ]
+            self.get_chart_isochron(
+                xls, sht, data_area, axis_range, title_name="Normal Isochron",
+                x_axis_name=f"{consts.sup_39}Ar / {consts.sup_36}Ar",
+                y_axis_name=f"{consts.sup_40}Ar / {consts.sup_36}Ar")
+        elif "inverse_isochron" in prop_name.lower():
+            data_area = [
+                f"Y{start_row}:Y{num_set1 + start_row - 1}", f"Z{start_row}:Z{num_set1 + start_row - 1}",
+                f"AA{start_row}:AA{num_set2 + start_row - 1}", f"AB{start_row}:AB{num_set2 + start_row - 1}",
+                f"AC{start_row}:AC{num_unselected + start_row - 1}",
+                f"AD{start_row}:AD{num_unselected + start_row - 1}",
+                f"AE{start_row}:AF{start_row}", f"AE{start_row + 1}:AF{start_row + 1}",
+                f"AG{start_row}:AH{start_row}", f"AG{start_row + 1}:AH{start_row + 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_3').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_3').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_3').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_3').yaxis.max,
+            ]
+            self.get_chart_isochron(
+                xls, sht, data_area, axis_range, title_name="Inverse Isochron",
+                x_axis_name=f"{consts.sup_39}Ar / {consts.sup_40}Ar",
+                y_axis_name=f"{consts.sup_36}Ar / {consts.sup_40}Ar")
+        elif "k-cl-ar_1_isochron" in prop_name.lower():
+            data_area = [
+                f"AI{start_row}:AI{num_set1 + start_row - 1}", f"AJ{start_row}:AJ{num_set1 + start_row - 1}",
+                f"AK{start_row}:AK{num_set2 + start_row - 1}", f"AL{start_row}:AL{num_set2 + start_row - 1}",
+                f"AM{start_row}:AM{num_unselected + start_row - 1}",
+                f"AN{start_row}:AN{num_unselected + start_row - 1}",
+                f"AO{start_row}:AP{start_row}", f"AO{start_row + 1}:AP{start_row + 1}",
+                f"AQ{start_row}:AR{start_row}", f"AQ{start_row + 1}:AR{start_row + 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_4').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_4').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_4').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_4').yaxis.max,
+            ]
+            self.get_chart_isochron(
+                xls, sht, data_area, axis_range, title_name="K-Cl-Ar 1 Isochron",
+                x_axis_name=f"{consts.sup_39}Ar / {consts.sup_38}Ar",
+                y_axis_name=f"{consts.sup_40}Ar / {consts.sup_38}Ar")
+        elif "k-cl-ar_2_isochron" in prop_name.lower():
+            data_area = [
+                f"AS{start_row}:AS{num_set1 + start_row - 1}", f"AT{start_row}:AT{num_set1 + start_row - 1}",
+                f"AU{start_row}:AU{num_set2 + start_row - 1}", f"AV{start_row}:AV{num_set2 + start_row - 1}",
+                f"AW{start_row}:AW{num_unselected + start_row - 1}",
+                f"AX{start_row}:AX{num_unselected + start_row - 1}",
+                f"AY{start_row}:AZ{start_row}", f"AY{start_row + 1}:AZ{start_row + 1}",
+                f"BA{start_row}:BB{start_row}", f"BA{start_row + 1}:BB{start_row + 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_5').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_5').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_5').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_5').yaxis.max,
+            ]
+            self.get_chart_isochron(
+                xls, sht, data_area, axis_range, title_name="K-Cl-Ar 2 Isochron",
+                x_axis_name=f"{consts.sup_39}Ar / {consts.sup_40}Ar",
+                y_axis_name=f"{consts.sup_38}Ar / {consts.sup_40}Ar")
+        elif "k-cl-ar_3_isochron" in prop_name.lower():
+            data_area = [
+                f"BC{start_row}:BC{num_set1 + start_row - 1}", f"BD{start_row}:BD{num_set1 + start_row - 1}",
+                f"BE{start_row}:BE{num_set2 + start_row - 1}", f"BF{start_row}:BF{num_set2 + start_row - 1}",
+                f"BG{start_row}:BG{num_unselected + start_row - 1}",
+                f"BH{start_row}:BH{num_unselected + start_row - 1}",
+                f"BI{start_row}:BJ{start_row}", f"BI{start_row + 1}:BJ{start_row + 1}",
+                f"BK{start_row}:BL{start_row}", f"BK{start_row + 1}:BL{start_row + 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_6').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_6').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_6').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_6').yaxis.max,
+            ]
+            self.get_chart_isochron(
+                xls, sht, data_area, axis_range, title_name="K-Cl-Ar 3 Isochron",
+                x_axis_name=f"{consts.sup_38}Ar / {consts.sup_39}Ar",
+                y_axis_name=f"{consts.sup_40}Ar / {consts.sup_39}Ar")
+        elif "degas_pattern" in prop_name.lower():
+            data_area = [
+                f"BM{start_row}:BM{total_rows + start_row - 1}",
+                f"BN{start_row}:BN{total_rows + start_row - 1}",
+                f"BO{start_row}:BO{total_rows + start_row - 1}",
+                f"BP{start_row}:BP{total_rows + start_row - 1}",
+                f"BQ{start_row}:BQ{total_rows + start_row - 1}",
+                f"BR{start_row}:BR{total_rows + start_row - 1}",
+                f"BS{start_row}:BS{total_rows + start_row - 1}",
+                f"BT{start_row}:BT{total_rows + start_row - 1}",
+                f"BU{start_row}:BU{total_rows + start_row - 1}",
+                f"BV{start_row}:BV{total_rows + start_row - 1}",
+                f"BW{start_row}:BW{total_rows + start_row - 1}",
+            ]
+            axis_range = [
+                basic.get_component_byid(self.sample, 'figure_8').xaxis.min,
+                basic.get_component_byid(self.sample, 'figure_8').xaxis.max,
+                basic.get_component_byid(self.sample, 'figure_8').yaxis.min,
+                basic.get_component_byid(self.sample, 'figure_8').yaxis.max,
+            ]
+            self.get_chart_degas_pattern(
+                xls, sht, data_area, axis_range,
+                title_name="Degas Pattern", x_axis_name=f"Sequence", y_axis_name=f"Argon Isotopes (%)")
+
     def create_initial_chart(self, xls: Workbook, chart_type: str = 'scatter'):
         # chartarea
         chartarea_dict = {'border': {'none': True}, 'fill': {'color': self.chartarea_color}}
@@ -1192,8 +1438,8 @@ class WritingWorkbook:
         # chart.title_name = title_name
         for each in series:
             chart.add_series(each)
-        # chart.x_axis.update({'name': x_axis_name, 'min': axis_range[0], 'max': axis_range[1]})
-        # chart.y_axis.update({'name': y_axis_name, 'min': axis_range[2], 'max': axis_range[3]})
+        chart.x_axis.update({'name': x_axis_name, 'min': axis_range[0], 'max': axis_range[1]})
+        chart.y_axis.update({'name': y_axis_name, 'min': axis_range[2], 'max': axis_range[3]})
 
         chart.set_legend({'none': False, 'position': 'top'})
 
@@ -1580,7 +1826,7 @@ class CreatePDF:
                         y=(yaxis_max - yaxis_min) * pos[1] + yaxis_min,
                         text=f"Age ={age} {chr(0xb1)} {sage} Ma<r>F = {F} {chr(0xb1)} {sF}<r>"
                              f"R<sub>0</sub> = {R0} {chr(0xb1)} {sR0}<r>"
-                             f"{MSWD = }, R<sup>2</sup> = {R2}<r>"
+                             f"{MSWD = }, r<sup>2</sup> = {R2}<r>"
                              f"{Chisq = }, {p = }",
                         size=10, clip=True, coordinate="scale", h_align="left", v_align="bottom",
                         color=color, rotate=0, z_index=150)