ararpy 0.1.22__tar.gz → 0.1.25__tar.gz

{ararpy-0.1.22 → ararpy-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ararpy
-Version: 0.1.22
+Version: 0.1.25
 Summary: A project for Ar-Ar geochronology
 Home-page: https://github.com/wuyangchn/ararpy.git
 Author: Yang Wu

{ararpy-0.1.22 → ararpy-0.1.25}/ararpy/__init__.py

@@ -16,10 +16,10 @@ from . import calc, smp, files, thermo, test
 """ Information """
 
 name = 'ararpy'
-version = '0.1.22'
+version = '0.1.25'
 __version__ = version
 full_version = version
-last_update = '2024-03-28'
+last_update = '2024-05-20'
 
 """ ArArPy Functions """
 

{ararpy-0.1.22 → ararpy-0.1.25}/ararpy/calc/regression.py

@@ -794,39 +794,31 @@ def power(a0: list, a1: list):
     def _pow_func(x, a, b, c):
         return a * x ** b + c
 
-    def _solve_pow(params):
+    def _residuals(params):
         a, b, c = params
-        x, y = [0, 0, 0], [0, 0, 0]
-        x[0] = sum(a1[:3]) / 3
-        y[0] = sum(a0[:3]) / 3
-        x[1] = sum(a1) / len(a1)
-        y[1] = sum(a0) / len(a0)
-        x[2] = sum(a1[-3:]) / 3
-        y[2] = sum(a0[-3:]) / 3
-        return np.array([
-            _pow_func(x[0], a, b, c) - y[0],
-            _pow_func(x[1], a, b, c) - y[1],
-            _pow_func(x[2], a, b, c) - y[2],
-        ])
-
-    def _get_sum(a, b, c):
-        y_predicted = [_pow_func(_x, a, b, c) for _x in a1]
-        return sum([(y_predicted[i] - a0[i]) ** 2 for i in range(len(a0))])
+        return [_pow_func(xi, a, b, c) - yi for xi, yi in zip(a1, a0)]
+
+    def _sum_squared_error(params):
+        return sum(r**2 for r in _residuals(params))
 
     def _get_abc(b):  # Return a, b, c given b based on linest regression
         f = linest(a0, [_x ** b for _x in a1])
         return f[5][1], b, f[0]
 
+    def _get_init():
+        f = linest(np.log(np.array(a0)), np.log(np.array(a1)))
+        return np.exp(f[0]), f[5][1], 0
+
     try:
-        a, b, c = fsolve(func=_solve_pow, x0=np.array([1, 1, 1]))  # initial estimate
+        a, b, c = _get_init()  # initial estimate
         count = 0
         step = 0.01
         while count < 100:
             a, b, c = _get_abc(b)
-            s = _get_sum(a, b, c)
+            s = _sum_squared_error([a, b, c])
             b_left, b_right = b - step * b, b + step * b
-            s_left = _get_sum(*_get_abc(b_left))
-            s_right = _get_sum(*_get_abc(b_right))
+            s_left = _sum_squared_error(_get_abc(b_left))
+            s_right = _sum_squared_error(_get_abc(b_right))
             if s_left > s > s_right:
                 b = b_right
                 continue
@@ -886,39 +878,32 @@ def exponential(a0: list, a1: list):
     def _exp_func(x, a, b, c):
         return a * b ** x + c
 
-    def _solve_exp(params):
+    def _residuals(params):
         a, b, c = params
-        x, y = [0, 0, 0], [0, 0, 0]
-        x[0] = sum(a1[:3]) / 3
-        y[0] = sum(a0[:3]) / 3
-        x[1] = sum(a1) / len(a1)
-        y[1] = sum(a0) / len(a0)
-        x[2] = sum(a1[-3:]) / 3
-        y[2] = sum(a0[-3:]) / 3
-        return np.array([
-            _exp_func(x[0], a, b, c) - y[0],
-            _exp_func(x[1], a, b, c) - y[1],
-            _exp_func(x[2], a, b, c) - y[2],
-        ])
-
-    def _get_sum(a, b, c):
-        y_predicted = [_exp_func(_x, a, b, c) for _x in a1]
-        return sum([(y_predicted[i] - a0[i]) ** 2 for i in range(len(a0))])
+        return [_exp_func(xi, a, b, c) - yi for xi, yi in zip(a1, a0)]
+
+    def _sum_squared_error(params):
+        return sum(r**2 for r in _residuals(params))
 
     def _get_ac(b):
-        f = linest(a0, [b ** _x for _x in a1])
+        f = linest(a0, [b ** xi for xi in a1])
         return f[5][1], b, f[0]
 
+    def _get_init():
+        f = linest(np.log(np.array(a0)), np.array(a1))
+        return np.exp(f[0]), np.exp(f[5][1]), 0
+
     try:
-        a, b, c = fsolve(_solve_exp, np.array([1, 1, 1]))
+        a, b, c = _get_init()
+        # a, b, c = minimize(_sum_squared_error, [a, b, c], method="Nelder-Mead").x  # 优化方法
         count = 0
         step = 0.01
         while count < 100:
             a, b, c = _get_ac(b)
-            s = _get_sum(a, b, c)
+            s = _sum_squared_error([a, b, c])
             b_left, b_right = b - step * b, b + step * b
-            s_left = _get_sum(*_get_ac(b_left))
-            s_right = _get_sum(*_get_ac(b_right))
+            s_left = _sum_squared_error(_get_ac(b_left))
+            s_right = _sum_squared_error(_get_ac(b_right))
             if s_left > s > s_right:
                 b = b_right
                 continue

{ararpy-0.1.22 → ararpy-0.1.25}/ararpy/files/raw_file.py

@@ -224,24 +224,23 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
 
     timezone = sample_info_index[3] if sample_info_index[3] != "" else "utc"
     while True:  # measurment steps sloop
+
+        # all text information
+        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
+
         # Zero datetime
         try:
             if check_box_index[2]:  # input_filter[134]: date in one string
-                zero_date = datetime_parse(
-                    get_item(file_contents, sample_info_index[16:19], base=[1, 1 - idx, 1]), sample_info_index[1])
+                zero_date = datetime_parse(options.get('ZeroYear'), sample_info_index[1])
             else:
-                zero_date = datetime(year=get_item(file_contents, sample_info_index[16:19], base=1),
-                                     month=get_item(file_contents, sample_info_index[22:25], base=[1, 1 - idx, 1]),
-                                     day=get_item(file_contents, sample_info_index[28:31], base=[1, 1 - idx, 1]))
+                zero_date = datetime(year=options.get('ZeroYear'), month=options.get('ZeroMon'),
+                                     day=options.get('ZeroDay'))
 
             if check_box_index[3]:  # input_filter[135]: time in one string
-                zero_time = datetime_parse(
-                    get_item(file_contents, sample_info_index[19:22], base=[1, 1 - idx, 1]), sample_info_index[2])
+                zero_time = datetime_parse(options.get('ZeroHour'), sample_info_index[2])
             else:
-                zero_time = datetime(year=2020, month=12, day=31,
-                                     hour=get_item(file_contents, sample_info_index[19:22], base=[1, 1 - idx, 1]),
-                                     minute=get_item(file_contents, sample_info_index[25:28], base=[1, 1 - idx, 1]),
-                                     second=get_item(file_contents, sample_info_index[31:34], base=[1, 1 - idx, 1]))
+                zero_time = datetime(year=2020, month=12, day=31, hour=options.get('ZeroHour'),
+                                     minute=options.get('ZeroMin'), second=options.get('ZeroSec'))
 
             zero_datetime = datetime(
                 zero_date.year, zero_date.month, zero_date.day, zero_time.hour, zero_time.minute, zero_time.second)
@@ -251,16 +250,10 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
             # print(f"Cannot parse zero datetime")
             zero_datetime = datetime(1970, 1, 1, 0, 0, 0).isoformat(timespec='seconds')
 
-        # Experiment name
-        try:
-            experiment_name = get_item(file_contents, sample_info_index[4:7], default="", base=[1, 1 - idx, 1])
-        except (TypeError, ValueError, IndexError):
-            # print(f"Cannot parse experiment name")
-            experiment_name = "ExpName"
-
         # Step name
         try:
-            step_name = get_item(file_contents, sample_info_index[7:10], default="", base=[1, 1 - idx, 1]) if input_filter[7] > 0 else ""
+            step_name = options.get('StepName')
+            experiment_name = options.get('ExpName')
             if check_box_index[1] and sample_info_index[0].strip() != "":
                 _res = string_parser(sample_info_index[0], file_name)
                 if _res is not None:
@@ -274,12 +267,13 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 raise ValueError(f"Step name not found")
         except (TypeError, ValueError, IndexError):
             # When parsing the step name fails, the end of the file has been reached
-            raise
-
-        # other information
-        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
+            # raise
+            break
+        else:
+            options.update({'StepName': step_name})
+            options.update({'ExpName': experiment_name})
 
-        current_step = [[step_name, zero_datetime, experiment_name, options]]
+        current_step = [[step_name, zero_datetime, options]]
 
         break_num = 0
         cycle_num = 0
@@ -370,7 +364,7 @@ def get_sample_info(file_contents: list, index_list: list, default="", base: Uni
     sample_info.update({
         "ExpName": get_item(file_contents, index_list[0:3], default=default, base=base),
         "StepName": get_item(file_contents, index_list[3:6], default=default, base=base),
-        "SmpType": get_item(file_contents, index_list[6:9], default=default, base=base),
+        "StepType": get_item(file_contents, index_list[6:9], default=default, base=base),
         "StepLabel": get_item(file_contents, index_list[9:12], default=default, base=base),
         "ZeroYear": get_item(file_contents, index_list[12:15], default=default, base=base),  # year
         "ZeroHour": get_item(file_contents, index_list[15:18], default=default, base=base),  # hour
@@ -402,7 +396,7 @@ def get_sample_info(file_contents: list, index_list: list, default="", base: Uni
         "StdAgeSig": get_item(file_contents, index_list[93:96], default=default, base=base),
         # "Experiment Name": get_item(file_contents, sample_info_index[0:3], default=default, base=base),
         # "Step Name": get_item(file_contents, sample_info_index[3:6], default=default, base=base),
-        # "Sample Type": get_item(file_contents, sample_info_index[6:9], default=default, base=base),
+        # "Step Type": get_item(file_contents, sample_info_index[6:9], default=default, base=base),
         # "Step Label": get_item(file_contents, sample_info_index[9:12], default=default, base=base),
         # "Zero Date Year": get_item(file_contents, sample_info_index[12:15], default=default, base=base),
         # "Zero Time Hour": get_item(file_contents, sample_info_index[15:18], default=default, base=base),

{ararpy-0.1.22 → ararpy-0.1.25}/ararpy/smp/sample.py

@@ -1110,27 +1110,33 @@ class Plot:
 
 class Sequence:
     def __init__(self, index=None, data=None, flag=None, name=None, datetime=None,
-                 type_str=None, results=None, coefficients=None, fitting_method=None,
+                 type_str=None, label=None, results=None, coefficients=None, fitting_method=None,
                  is_estimated=False, options=None, **kwargs):
         if options is None:
             options = {}
-        self.index = index
         if name is None or not isinstance(name, str):
-            name = ""
-        self.name = name.strip()
-        self.datetime = datetime
-        self.data = data
+            name = options.get('StepName', "")
         # flag is to check if the data point is selected
         if flag is None and data is not None:
             flag = [[j if i == 0 else True for i, j in enumerate(_m)] for _m in data]
-        self.flag = flag
-        self.type_str = type_str
+        if type_str is None:
+            type_str = options.get('StepType', "Unknown")
+        if label is None:
+            label = options.get('StepLabel', "")
         if results is None:
             results = []
         if fitting_method is None:
             fitting_method = []
         if coefficients is None:
             coefficients = []
+
+        self.index = index
+        self.datetime = datetime
+        self.data = data
+        self.name = name.strip()
+        self.flag = flag
+        self.type_str = type_str.strip()
+        self.label = str(label).strip()
         self.results = results
         self.coefficients = coefficients
         self.fitting_method = fitting_method
@@ -1211,9 +1217,8 @@ class RawData:
                     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]
+                    options=item[0][2]
                 ) for index, item in enumerate(data)]
         else:
             self.sequence: List[Sequence] = []

{ararpy-0.1.22 → ararpy-0.1.25}/ararpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ararpy
-Version: 0.1.22
+Version: 0.1.25
 Summary: A project for Ar-Ar geochronology
 Home-page: https://github.com/wuyangchn/ararpy.git
 Author: Yang Wu

{ararpy-0.1.22 → ararpy-0.1.25}/setup.py

@@ -16,7 +16,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setuptools.setup(
     name='ararpy',  #
-    version='0.1.22',  # version
+    version='0.1.25',  # version
     author='Yang Wu',
     author_email='wuycug@hotmail.com',
     description='A project for Ar-Ar geochronology',  # short description