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

ararpy/smp/export.py

@@ -17,9 +17,11 @@ import sys
 import pickle
 import traceback
 import pdf_maker as pm
+import numpy as np
 from decimal import Decimal
 
-from ..calc import arr, isochron
+from ..calc import arr, isochron, spectra
+from ..calc.basic import get_random_digits
 from . import basic, sample, consts
 
 Sample = sample.Sample
@@ -41,6 +43,467 @@ def to_pdf(file_path: str, figure: str, smp: Sample):
     pdf.save(figure=figure)
 
 
+def get_cv_from_dict(data: dict):
+    # create a canvas
+    cv = pm.Canvas(width=17, height=12, unit="cm", show_frame=True, clip_outside_plot_areas=False)
+    # change frame outline style
+    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,)
+        # 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)
+        for stick in data['xAxis'][i]['interval']:
+            start = pt.scale_to_points(stick, scale[2])
+            end = pt.scale_to_points(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,
+                        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)
+            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,
+                        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)
+        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)
+        plots.append(pt)
+    # draw series
+    for se in data['series']:
+        data = se.get('data', [])
+        try:
+            pt = plots[se.get('axis_index', 0)]
+        except IndexError:
+            continue
+        if 'line' in se['type']:
+            for index in range(1, len(data)):
+                pt.line(
+                    start=data[index - 1], end=data[index], width=se.get('line_width', 1),
+                    line_style=se.get('line_style', 'solid'), name=se['name'],
+                    color=se.get('color', 'black'), clip=True, line_caps=se.get('line_caps', 'none'),
+                    z_index=se.get('z_index', 9))
+        if 'scatter' in se['type'] and se['name'] != 'Text':
+            for each in data:
+                pt.scatter(
+                    each[0], each[1], fill_color=se.get('fill_color', 'black'), size=se.get('size', 5),
+                    stroke_color=se.get('stroke_color', se.get('color', 'black')),
+                    z_index=se.get('z_index', 9)
+                )
+        if 'scatter' in se['type'] and se['name'] == 'Text' or 'text' in se['type']:
+            for each in data:
+                pt.text(*each[:2], **se)
+        if 'rect' in se['type']:
+            for each in data:
+                lb = each[:2]; width, height = each[2:4]
+                pt.rect(lb, width, height, **se)
+
+    return cv
+
+
+def export_chart_to_pdf(data: dict, filepath: str = "", **kwargs):
+    """
+
+    Parameters
+    ----------
+    filepath: str
+    data: dict
+        - file_name: string
+            file name, like "24WHA0001"
+        - data: list of dicts
+            properties:
+            - name: string
+                diagram name, like "Age spectra"
+
+            - xAxis: list
+                properties:
+                - extend: list
+                    limits of values of axis, like [0, 100]
+                - interval: list
+                    sticks location, like [0, 20, 40, 60, 80, 100]
+                - title: string
+                - name_location: string
+                    axis title location, 'middle'
+
+            - yAxis: same as xAxis
+
+            - series: list
+                properties:
+                - type: string
+                    series type, 'line', 'scatter', 'text', and any string contains these characters
+                - id: string
+                - name: string
+                - color: string or list
+                    color for outlines, color name | RGB triplet | Hex color code
+                - fill_color: string or list
+                    color for filling markers, format is similar to that of color
+                - data: 2-dimensional array
+                    [[x1, y1], [x2, y2], ...]
+                - axis_index: int
+                    index of axis to combine with, which is useful for plotting on different scales.
+
+                optional:
+                - line_caps: string
+                    for lines only, 'square', 'none', 'butt'
+                - text: string
+                    for texts only
+                - size: int
+                    for scatters only
+    **kwargs:
+        author, producer, creator, page_size, ppi, ...
+
+    Returns
+    -------
+
+    """
+    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):
+            file.add_page()
+
+    # save pdf
+    file.save()
+
+    return filepath
+
+
+def get_plot_data(smp: Sample, diagram: str = 'age spectra', **options):
+    """
+
+    Parameters
+    ----------
+    smp
+    diagram
+    color
+    options
+
+    Returns
+    -------
+
+    """
+    if diagram.lower() == "age spectra":
+        xAxis, yAxis, series = _get_plot_data_age_spectra(smp, **options)
+    elif diagram.lower() == "inverse isochron":
+        xAxis, yAxis, series = _get_plot_data_inv_isochron(smp, **options)
+    elif "degas spectra" in diagram.lower():
+        xAxis, yAxis, series = _get_plot_data_degas_spectra(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)
+    else:
+        raise KeyError
+
+    data = {
+        'name': smp.name(), 'xAxis': xAxis, 'yAxis': yAxis, 'series': series
+    }
+
+    print(data)
+
+    return data
+
+
+def _get_plot_data_age_spectra(smp: sample, **options):
+    color = options.get('color', 'black')
+    xAxis, 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()}',
+        '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()}',
+        '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]:
+        series.append({
+            'type': 'text', 'id': f'text-{get_random_digits()}', 'name': f'text-{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],
+            'axis_index': 1,
+        })
+
+    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,
+    })
+    xAxis.append({
+        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
+        'title': '', 'name_location': 'middle',
+        'line_width': 1, 'line_style': 'solid', 'z_index': 0,
+    })
+    yAxis.append({
+        'extent': [0, 25], 'interval': [0, 5, 10, 15, 20, 25], 'id': 0, 'show_frame': True,
+        'title': 'Apparent Age (Ma)', 'name_location': 'middle',
+        'line_width': 1, 'line_style': 'solid', 'z_index': 9,
+    })
+    yAxis.append({
+        'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
+        'title': '', 'name_location': 'middle',
+        'line_width': 1, 'line_style': 'solid', 'z_index': 0,
+    })
+    return xAxis, yAxis, series
+
+
+def _get_plot_data_inv_isochron(smp: sample, **options):
+    color = options.get('color', 'black')
+    xAxis, yAxis, series = [], [], []
+    age = smp.ApparentAgeValues[2:4]
+    ar = smp.DegasValues[20]
+    data = np.array(smp.InvIsochronPlot.data)
+    set1 = smp.InvIsochronPlot.set1.data
+    set2 = smp.InvIsochronPlot.set2.data
+    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,
+        '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,
+        '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,
+        'data': (data[[0, 2], :][:, set3]).transpose().tolist(),
+        'axis_index': 0, 'z_index': 0
+    })
+
+    text1 = smp.InvIsochronPlot.text1
+    text2 = smp.InvIsochronPlot.text2
+
+    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,
+    })
+
+    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
+
+
+def _get_plot_data_degas_pattern(smp: sample, **options):
+    color = options.get('color', 'black')
+    plot = smp.DegasPatternPlot
+    xAxis, yAxis, series = [], [], []
+    argon = smp.DegasValues[20]  # Ar39K as default
+    while argon[-1] == 0:
+        argon = argon[:-1]
+    y = [argon[i] / sum(argon[i:]) * 100 for i in range(len(argon))]
+    x = list(range(1, len(argon) + 1))
+    data = np.array([x, y])
+    # set 1
+    series.append({
+        'type': 'series.scatter', 'id': f'scatter-{get_random_digits()}', 'name': f'scattter-{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
+    })
+
+    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,
+        '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,
+        'title': 'YYYY', 'name_location': 'middle',
+    })
+    return xAxis, yAxis, series
+
+
+def _get_plot_data_degas_spectra(smp: sample, **options):
+    name = options.get('diagram_name', '39Ar')
+    color = options.get('color', 'black')
+    plot = smp.DegasPatternPlot
+    xAxis, 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
+        sar = np.array(smp.DegasValues[nindex[name[:2]] + 1], dtype=np.float64)
+    elif 'total' in name:
+        all_ar = np.array(smp.CorrectedValues, dtype=np.float64)  # 20-21 Ar39
+        ar, sar = arr.add(*all_ar.reshape(5, 2, len(all_ar[0])))
+        ar = np.array(ar); sar = np.array(sar)
+    else:
+        raise KeyError
+
+    while ar[-1] == 0:
+        ar = ar[:-1]
+    x = list(range(0, len(ar)))
+    y = [0 for i in range(len(ar))]
+    width = [1 for i in range(len(ar))]
+    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()}',
+        'color': color, 'myType': 'rect', 'line_width': 1,
+        'data': data.transpose().tolist(),
+        'axis_index': 0, 'z_index': 99
+    })
+
+    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': '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',
+    })
+    return xAxis, yAxis, series
+
+
+def _get_plot_data_degas_curve(smp: sample, **options):
+    name = options.get('diagram_name', '39Ar')
+    color = options.get('color', 'black')
+    xAxis, 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
+        sar = np.array(smp.DegasValues[nindex[name[:2]] + 1], dtype=np.float64)
+    elif 'total' in name:
+        all_ar = np.array(smp.CorrectedValues, dtype=np.float64)  # 20-21 Ar39
+        ar, sar = arr.add(*all_ar.reshape(5, 2, len(all_ar[0])))
+        ar = np.array(ar); sar = np.array(sar)
+    else:
+        raise KeyError
+
+    while ar[-1] == 0:
+        ar = ar[:-1]
+    x = list(range(0, len(ar) + 1))
+    f = ar / sum(ar) * 100
+    released = np.zeros(len(ar) + 1)
+    remained = np.zeros(len(ar) + 1) + 100
+    for i in range(1, len(ar) + 1):
+        released[i] = sum(f[:i])
+        remained[i] = 100 - released[i]
+
+    # line
+    series.append({
+        'type': 'line', 'id': f'line-{get_random_digits()}', 'name': f'line-{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()}',
+        '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
+
+
 class ExcelTemplate:
     def __init__(self, **kwargs):
         self.name = ""

ararpy/smp/json.py

@@ -22,7 +22,8 @@ def dumps(a):
 
 
 def loads(a):
-    return json.loads(a)
+    # null will be converted to None by default, replace None with np.nan
+    return json.loads(a, object_hook=myHook)
 
 
 class MyEncoder(json.JSONEncoder):
@@ -51,3 +52,13 @@ class MyEncoder(json.JSONEncoder):
         if not isinstance(obj, (int, str, list, dict, tuple, float)):
             print(f"Special type, {type(obj) = }, {obj = }")
         return super(MyEncoder, self).default(obj)
+
+
+def myHook(obj):
+    if isinstance(obj, dict):
+        return {k: myHook(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [myHook(v) for v in obj]
+    elif obj is None:
+        return np.nan
+    return obj

ararpy/smp/plots.py

@@ -61,16 +61,20 @@ def set_plot_data(sample: Sample, isInit: bool = True, isIsochron: bool = True,
         try:
             initial_plot_data(sample)
         except (Exception, BaseException):
-            print(traceback.format_exc())
+            # print(traceback.format_exc())
             pass
 
     # Recalculate isochron lines
     if isIsochron:
         try:
             recalc_isochrons(sample, **kwargs)
+        except (Exception, BaseException):
+            # print(traceback.format_exc())
+            pass
+        try:
             reset_isochron_line_data(sample)
         except (Exception, BaseException):
-            print(traceback.format_exc())
+            # print(traceback.format_exc())
             pass
 
     # Recalculate plateaus
@@ -78,7 +82,7 @@ def set_plot_data(sample: Sample, isInit: bool = True, isIsochron: bool = True,
         try:
             recalc_plateaus(sample)
         except (Exception, BaseException):
-            print(traceback.format_exc())
+            # print(traceback.format_exc())
             pass
 
 
@@ -237,7 +241,7 @@ def get_isochron_results(data: list, smp: Sample, sequence, figure_type: int = 0
     try:
         regression_res = regression_method(*data[:5])
     except (Exception, BaseException):
-        print(f"Warning: {traceback.format_exc()}")
+        # print(f"Warning: {traceback.format_exc()}")
         return iso_res
     else:
         iso_res.update(dict(zip(reg_res_index, regression_res)))
@@ -305,11 +309,11 @@ def get_3D_results(data: list, sequence: list, sample: Sample):
             Q = 1 - np.exp(-1 * sample.TotalParam[46][0] * sum(sample.TotalParam[32]) / len(sample.TotalParam[32]))
             P = PQ / Q
         except:
-            print(f"Warning: {traceback.format_exc()}")
+            # print(f"Warning: {traceback.format_exc()}")
             P = 0
         age = basic.calc_age([f, sf], smp=sample)
     except:
-        print(f"Warning: {traceback.format_exc()}")
+        # print(f"Warning: {traceback.format_exc()}")
         k = [0] * 15
         age = [0] * 4
         ar40ar36, sar40ar36, P = 0, 0, 0

ararpy/smp/raw.py

@@ -50,8 +50,15 @@ def to_raw(file_path: Union[str, List[str]], input_filter_path: Union[str, List[
         data = res.get('data', None)
         sequences = res.get('sequences', None)
         sequence_num = len(data) if data is not None else len(sequences)
-        raw = RawData(name=file_name, data=data, isotopic_num=10, sequence_num=sequence_num,
-                      source=[file_path], sequence=sequences, unit=str(input_filter[30]))
+        # default fitting method, all exponential
+        # <option value=0>Linear</option>
+        # <option value=1>Quadratic</option>
+        # <option value=2>Exponential</option>
+        # <option value=3>Power</option>
+        # <option value=4>Average</option>
+        fitting_method = [2, 0, 2, 2, 2]
+        raw = RawData(name=file_name, data=data, isotopic_num=10, sequence_num=sequence_num, source=[file_path],
+                      sequence=sequences, unit=str(input_filter[30]), fitting_method=[*fitting_method])
     else:
         raise ValueError("File path and input filter should be both string or list with a same length.")
     return raw

ararpy/smp/sample.py

@@ -119,8 +119,8 @@ TOTAL_PARAMS_HEADERS = [
     '\u2074\u2070Ar/\u00B3\u2076Ar air', '%1\u03C3',
     '\u00B3\u2078Ar/\u00B3\u2076Ar air', '%1\u03C3',  # 95-98
     'Isochron Fitting', 'Convergence', 'Iteration', 'Discrimination',  # 99-102
-    'Not Zero', 'Corr Blank', 'Corr Discr', 'Corr \u00B3\u2077Ar Decay',
-    'Corr \u00B3\u2079Ar Decay',  # 103-107
+    'Not Zero', 'Corr Blank', 'Corr Discr', 'Corr \u00B3\u2077Ar Decay',  # 103-106
+    'Corr \u00B3\u2079Ar Decay',  # 107
     'Ca Degassing', 'K Degassing', 'Cl Degassing', 'Trap Degassing',  # 108-111
     'Using Min Equation',
     # 'Recalibration', 'Using Std Age', 'Use Std Ratio',  # 112-115  to be completed
@@ -137,6 +137,11 @@ TOTAL_PARAMS_HEADERS = [
     'Heating Time (s)',  # 125
     'Heating Actual Temp (C)',  # 126
     'Heating AT 1\u03C3',  # 127
+    '36Ar Gain', '%1\u03C3',  # 128-129
+    '37Ar Gain', '%1\u03C3',  # 130-131
+    '38Ar Gain', '%1\u03C3',  # 132-133
+    '39Ar Gain', '%1\u03C3',  # 134-135
+    '40Ar Gain', '%1\u03C3',  # 136-137
 ]
 
 SAMPLE_INTERCEPT_SHORT_HEADERS = [
@@ -245,6 +250,11 @@ TOTAL_PARAMS_SHORT_HEADERS = [
     'HeatingTime',  # 125
     'HeatingActualTemp',  # 126
     'HeatingActualTempError',  # 127
+    '36Gain', '%1s',  # 128-129
+    '37Gain', '%1s',  # 130-131
+    '38Gain', '%1s',  # 132-133
+    '39Gain', '%1s',  # 134-135
+    '40Gain', '%1s',  # 136-137
 ]
 
 DEFAULT_PLOT_STYLES = {
@@ -731,7 +741,7 @@ DEFAULT_PLOT_STYLES = {
     },
 }
 
-VERSION = '20240730'
+VERSION = '20241028'
 
 NAMED_DICT = {
     "unknown": {"header": SAMPLE_INTERCEPT_HEADERS.copy()},
@@ -832,7 +842,8 @@ class Sample:
         # self.__version = '20230730'  # delete calcparams attribute
         # self.__version = '20230827'  # using merge smp to update arr version
         # self.__version = '20231116'  # change smp parameters
-        self.__version = '20240730'  # change parameter table for thermo calculation
+        # self.__version = '20240730'  # change parameter table for thermo calculation
+        self.__version = '20241028'  # gain correction
 
     @property
     def version(self):
@@ -854,7 +865,7 @@ class Sample:
 
     def sequence(self) -> ArArBasic: ...
 
-    def recalculate(self, *args): ...
+    def recalculate(self, *args, **kwargs): ...
 
     def plot_age_plateau(self): ...
 
@@ -1144,16 +1155,21 @@ class RawData:
         self.isotopic_num = isotopic_num
         self.sequence_num = sequence_num
         self.interpolated_blank = None
-        if data is not None:
+        if sequence is not None:
+            self.sequence = sequence
+        elif data is not None:
             self.sequence: List[Sequence] = [
-                Sequence(index=index, name=item[0][0] if isinstance(item[0][0], str) and item[0][
-                    0] != '' else f"{self.name}-{index + 1:02d}", data=item[1:], datetime=item[0][1], type_str=item[0][2],
-                         fitting_method=[0] * 5, options=item[0][3])
-                for index, item in enumerate(data)]
+                Sequence(
+                    index=index,
+                    name=item[0][0] if isinstance(item[0][0], str) and item[0][0] != '' else f"{self.name}-{index + 1:02d}",
+                    data=item[1:],
+                    datetime=item[0][1],
+                    type_str=item[0][2],
+                    fitting_method=[*kwargs.get("fitting_method", [0] * 5)],
+                    options=item[0][3]
+                ) for index, item in enumerate(data)]
         else:
             self.sequence: List[Sequence] = []
-        if sequence is not None:
-            self.sequence = sequence
         for k, v in kwargs.items():
             if hasattr(self, k) and type(getattr(self, k)) is MethodType:
                 continue