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

ararpy/smp/sample.py

@@ -743,7 +743,7 @@ DEFAULT_PLOT_STYLES = {
     },
 }
 
-VERSION = '20250102'
+VERSION = '20250301'
 
 NAMED_DICT = {
     "unknown": {"header": SAMPLE_INTERCEPT_HEADERS.copy()},
@@ -846,7 +846,8 @@ class Sample:
         # self.__version = '20231116'  # change smp parameters
         # self.__version = '20240730'  # change parameter table for thermo calculation
         # self.__version = '20241028'  # gain correction
-        self.__version = '20250102'  # gain correction to blanks
+        # self.__version = '20250102'  # gain correction to blanks
+        self.__version = '20250301'  # error sigma adjustment
 
     @property
     def version(self):
@@ -943,14 +944,14 @@ class Table:
         if header is None:
             header = ['']
         if data is None:
-            data = [['']]
+            data = [['' for i in range(len(header))]]
         if colcount is None:
             colcount = len(header)
         if rowcount is None:
             rowcount = len(data[0])
         if coltypes is None:
             # Note the difference between [xx] * 10 and [xx for i in range(10)]
-            coltypes = [{'type': 'numeric'} for i in range(colcount)]
+            coltypes = [{'type': 'text'} for i in range(colcount)]
         self.id = id
         self.name = name
         self.colcount = colcount
@@ -958,12 +959,13 @@ class Table:
         self.header = header
         self.data = data
         self.coltypes = coltypes
-        self.numeric_indexes = numeric_indexes
-        self.text_indexes = text_indexes
-        if text_indexes is not None and numeric_indexes is not None:
-            self.set_coltypes()
+        self.text_indexes = text_indexes if text_indexes is not None else []
+        self.numeric_indexes = numeric_indexes if numeric_indexes is not None else list(set(range(0, colcount)) - set(self.text_indexes))
+        self.decimal_places = 6
+
         for k, v in kwargs.items():
             setattr(self, k, v)
+        self.set_coltypes()
 
     def set_coltypes(self):
         for i in self.text_indexes:
@@ -971,7 +973,10 @@ class Table:
                 self.coltypes[i].update({'type': 'text'})
         for i in self.numeric_indexes:
             if i < self.colcount:
-                self.coltypes[i].update({'type': 'numeric'})
+                self.coltypes[i].update({
+                    'type': 'numeric',
+                    'numericFormat': {'pattern': {'mantissa': self.decimal_places}},
+                })
 
 
 class Plot:

ararpy/smp/style.py

@@ -58,6 +58,13 @@ def set_plot_style(smp: Sample):
                 setattr(figure, 'title', Plot.Text())
             setattr(getattr(figure, 'title'), 'text', f"{suffix} {getattr(figure, 'name', '')}")
 
+    age_unit = "Undefined"
+    try:
+        age_unit = str(smp.Info.preference['ageUnit']).capitalize()
+    except:
+        print(traceback.format_exc())
+    smp.AgeSpectraPlot.yaxis.title.text = f"Apparent Age ({age_unit})"
+
 
 def reset_plot_scale(smp: Sample, only_figure: str = None):
     """
@@ -184,9 +191,10 @@ def set_table_style(sample: Sample):
     for key, comp in basic.get_components(sample).items():
         if isinstance(comp, Table):
             comp.header = TABLEHEADER(index=int(comp.id))
-            comp.colcount = len(comp.header)
-            comp.coltypes = [{'type': 'numeric'}] * (comp.colcount)
-            textindexs = getattr(comp, 'textindexs', [0]) if hasattr(comp, 'textindexs') else [0]
-            for i in textindexs:
-                comp.coltypes[i] = {'type': 'text'}
+            comp.set_coltypes()
+            # comp.colcount = len(comp.header)
+            # comp.coltypes = [{'type': 'numeric'}] * (comp.colcount)
+            # text_indexes = getattr(comp, 'text_indexes', [0]) if hasattr(comp, 'text_indexes') else [0]
+            # for i in text_indexes:
+            #     comp.coltypes[i] = {'type': 'text'}
 

ararpy/smp/table.py

@@ -9,6 +9,8 @@
 #
 #
 """
+import ast
+import re
 import copy
 from .. import calc
 from . import (sample as samples, basic)
@@ -96,6 +98,12 @@ def update_handsontable(smp: Sample, data: list, id: str):
             'true': True, 'false': False, 'True': True, 'False': False, '1': True, '0': False, 'none': False,
         }
         return [bools_dict.get(str(col).lower(), False) for col in cols]
+
+    def _digitize_data(a):
+        # pattern = r'^[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?$'
+        # return [[ast.literal_eval(str(cell)) if re.fullmatch(pattern, str(cell)) else np.nan if str(cell) == "" else cell for cell in row] for row in a]
+        return a
+
     try:
         smp.SequenceName = data[0]
     except IndexError:
@@ -104,47 +112,37 @@ def update_handsontable(smp: Sample, data: list, id: str):
     update_all_table = False
     try:
         if data[1] != smp.SequenceValue:
+            update_all_table = True
             smp.SequenceValue = data[1]
     except IndexError:
         pass
-    else:
-        update_all_table = True
 
     if id == '1':  # 样品值
         data = _normalize_data(data, len(samples.SAMPLE_INTERCEPT_HEADERS), 2)
-        smp.SampleIntercept = data
+        smp.SampleIntercept = _digitize_data(data)
     elif id == '2':  # 本底值
         data = _normalize_data(data, len(samples.BLANK_INTERCEPT_HEADERS), 2)
-        smp.BlankIntercept = data
+        smp.BlankIntercept = _digitize_data(data)
     elif id == '3':  # 校正值
         data = _normalize_data(data, len(samples.CORRECTED_HEADERS), 2)
-        smp.CorrectedValues = data
+        smp.CorrectedValues = _digitize_data(data)
     elif id == '4':  # Degas table
         data = _normalize_data(data, len(samples.DEGAS_HEADERS), 2)
-        smp.DegasValues = data
+        smp.DegasValues = _digitize_data(data)
     elif id == '5':  # 发行表
         data = _normalize_data(data, len(samples.PUBLISH_TABLE_HEADERS), 2)
-        smp.PublishValues = data
+        smp.PublishValues = _digitize_data(data)
     elif id == '6':  # 年龄谱
         data = _normalize_data(data, len(samples.SPECTRUM_TABLE_HEADERS), 2)
-        smp.ApparentAgeValues = data
+        smp.ApparentAgeValues = _digitize_data(data)
     elif id == '7':  # 等时线
-        smp.IsochronMark = data[2]
+        smp.IsochronMark = _digitize_data(data)[2]
         data = _normalize_data(data, len(samples.ISOCHRON_TABLE_HEADERS), 3)
-        smp.IsochronValues = data
-        smp.SelectedSequence1 = [
-            i for i in range(len(smp.IsochronMark)) if str(smp.IsochronMark[i]) == "1"]
-        smp.SelectedSequence2 = [
-            i for i in range(len(smp.IsochronMark)) if str(smp.IsochronMark[i]) == "2"]
-        smp.UnselectedSequence = [
-            i for i in range(len(smp.IsochronMark)) if
-            i not in smp.SelectedSequence1 + smp.SelectedSequence2]
-        #
-        smp.Info.results.selection[0]['data'] = smp.SelectedSequence1
-        smp.Info.results.selection[1]['data'] = smp.SelectedSequence2
-        smp.Info.results.selection[2]['data'] = smp.UnselectedSequence
+        smp.IsochronValues = _digitize_data(data)
+        smp.sequence()
     elif id == '8':  # 总参数
         data = _normalize_data(data, len(samples.TOTAL_PARAMS_HEADERS), 2)
+        data = _digitize_data(data)
         data[101: 112] = [_strToBool(i) for i in data[101: 112]]
         smp.TotalParam = data
     else:

ararpy/{argon_diffusion_simulator → thermo}/__init__.py

@@ -9,4 +9,4 @@
 #
 # 
 """
-from . import main
+from . import atomic_level_random_walk as arw, basic

ararpy/thermo/arrhenius.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2025 Yang 
+# ararpy - arrhenius
+# ==========================================
+#
+#
+# 
+"""
+
+from . import basic
+
+

ararpy/{argon_diffusion_simulator/main.py → thermo/atomic_level_random_walk.py}

@@ -3,7 +3,7 @@
 """
 # ==========================================
 # Copyright 2024 Yang
-# ArgonDiffusionRandomWalk - main
+# argon atomic_level_random_walk model - main
 # ==========================================
 #
 #
@@ -53,7 +53,7 @@ def _uniform_sphere_step(step_length, shape):
 
 
 def walker(pos, step_length, total_nsteps, min_bound, max_bound, scale=0., compensation=0, remove=True,
-           conditions=None, boundary_factor=1):
+           conditions=None, boundary_factor=1, decay=0, parent=0):
 
     if len(pos) == 0:
         return pos
@@ -122,7 +122,7 @@ def walker(pos, step_length, total_nsteps, min_bound, max_bound, scale=0., compe
 
 
 def walker2(pos: np.ndarray, duration, step_length, min_bound, max_bound, time_scale, frequency,
-            conditions=None, remove: bool = True):
+            conditions=None, remove: bool = True, decay=0, parent=0):
     """
     :return:
     """
@@ -132,6 +132,7 @@ def walker2(pos: np.ndarray, duration, step_length, min_bound, max_bound, time_s
 
     dimension = pos.shape[-1] if len(pos.shape) > 1 else 1
 
+
     dt = time_scale
     if conditions is None:
         if dimension == 3:
@@ -141,6 +142,13 @@ def walker2(pos: np.ndarray, duration, step_length, min_bound, max_bound, time_s
 
     for step in range(int(1e16)):
 
+        n = parent - int(parent * math.exp(-1 * decay * dt / (3600 * 24 * 365.2425)))
+        # print(f"number of new pos = {n}")
+        parent = parent - n
+        new_pos = np.random.uniform(max(max_bound), min(min_bound), size=(int(n), dimension))
+        new_pos = new_pos[np.all((new_pos >= min_bound) & (new_pos <= max_bound), axis=1)]
+        pos = np.concatenate((pos, new_pos), axis=0)
+
         res = np.zeros(0).reshape(0, dimension)
         for index, each in enumerate(conditions):
             # each = (x1, y1, z1, x2, y2, z2, gamma)
@@ -235,6 +243,7 @@ class Domain:
         # 初始化粒子位置，随机分布在网格内
         # 初始原子个数  1e14 原子密度 个/立方厘米   1e-4是单位换算 cm/µm
         natoms = int(self.atom_density ** (self.dimension / 3) * (abs(max(self.max_bound) - min(self.min_bound)) * 1e-4) ** self.dimension)
+        natoms = 1 if natoms == 0 else natoms
         self.positions = np.random.uniform(max(self.max_bound), min(self.min_bound), size=(int(natoms), self.dimension))
         self.positions = self.positions[np.all((self.positions >= self.min_bound) & (self.positions <= self.max_bound), axis=1)]
         for dom in self.inclusions:
@@ -320,7 +329,7 @@ class DiffSimulation:
 
     def run_sequence(self, times, temperatures, statuses, targets, domains: List[Domain], nsteps_factor=None,
                      simulating: bool = False, epsilon=0.001, start_time=0, k=1.2, use_walker1=True,
-                     scoring: bool = False):
+                     scoring: bool = False, decay=0, parent=0):
         pos = copy.deepcopy(self.positions)
         self.seq = []  # 用于记录参数
 
@@ -369,7 +378,8 @@ class DiffSimulation:
                     _pos = walker(
                         copy.deepcopy(pos), step_length=step_length, total_nsteps=total_steps,
                         min_bound=self.min_bound, max_bound=self.max_bound, scale=scale,
-                        compensation=compensation, remove=True, conditions=conditions, boundary_factor=boundary_factor
+                        compensation=compensation, remove=True, conditions=conditions, boundary_factor=boundary_factor,
+                        decay=decay, parent=parent
                     )
 
                     # self.seq[index].update({
@@ -383,7 +393,7 @@ class DiffSimulation:
                     scale = k
                     _pos = walker2(copy.deepcopy(pos), duration=heating_duration, step_length=step_length,
                                    min_bound=self.min_bound, max_bound=self.max_bound, time_scale=scale,
-                                   frequency=self.frequency, conditions=conditions, remove=True)
+                                   frequency=self.frequency, conditions=conditions, remove=True, decay=decay, parent=parent)
                     boundary_factor = 1
                     compensation = 0
 
@@ -429,6 +439,8 @@ class DiffSimulation:
 
             print(f"{index = } {duration} - {heating_duration = } - {temperature = } - {total_steps = } - conc = {len(pos) / self.natoms * 100:.2f}% - {time.time() - _start:.5f}s")
 
+        self.positions = copy.deepcopy(pos)
+
     def run_persecond(self, times, temperatures, statuses, targets, domains: List[Domain], scale=None,
                      simulation: bool = False, epsilon=0.001, start_time=0):
         seq = []
@@ -442,6 +454,83 @@ class DiffSimulation:
 
 
 def run(times, temps, statuses, energies, fractions, ndoms: int = 1, grain_szie=275, atom_density=1e10, frequency=1e13,
+        dimension: int = 3, targets: list = None, epsilon: float = 0.001, simulation: bool = False,
+        file_name: str = "Y70", ignore_error: bool = False, positions=None, **kwargs):
+    """
+    :param times:
+    :param temps:
+    :param statuses:
+    :param energies:
+    :param fractions:
+    :param dimension:
+    :param ndoms:
+    :param targets:
+    :param epsilon:
+    :param simulation:
+    :param file_name:
+    :param ignore_error:
+    :return:
+    """
+
+    demo = DiffSimulation()
+
+    def _(n, es, fs):
+        # fs 应从大到小，父空间在前，子空间在后
+
+        # demo.grain_size = 300
+        # demo.size_scale = 0.05
+        # demo.atom_density = 1e14  # 原子密度 个/立方厘米
+        demo.dimension = dimension
+
+        demo.size_scale = 1
+        demo.grain_size = grain_szie
+        demo.atom_density = atom_density  # 原子密度 个/立方厘米
+        demo.frequency = frequency
+
+        # domains应该从外到内
+        domains = []
+        for i in range(n-1, 0-1, -1):
+            size = int(demo.grain_size * fs[i]) * demo.size_scale
+            center = np.zeros(demo.dimension)
+            if i == 2:
+                ad = demo.atom_density * 5 / 4
+            else:
+                ad = demo.atom_density
+            dom = Domain(
+                dimension=demo.dimension, atom_density=ad, min_bound=center - size / 2, max_bound=center + size / 2,
+                energy=es[i], fraction=fs[i], inclusions=[domains[-1]] if len(domains) >= 1 else []
+            )
+            domains.append(dom)
+        # domains应该从外到内, 上面为了inclusion以及方便不同扩散域设置不同的密度，要按照从小到大的顺序生成，但是后面行走的时候要根据不同条件设置系数，要从外到内
+        demo.domains = sorted(domains, key=lambda dom: dom.fraction, reverse=True)
+
+        demo.setup()
+
+        demo.name = f"{file_name}"
+
+        print(f"Total Atoms: {demo.natoms}, atoms in each dom: {[dom.natoms for dom in demo.domains]} filename: {demo.name}")
+
+        if positions is not None:
+            demo.positions = positions
+            demo.natoms = len(positions)
+
+        demo.run_sequence(times=times, temperatures=temps, statuses=statuses, targets=targets, domains=demo.domains,
+                          epsilon=epsilon, simulating=simulation, **kwargs)
+        # demo.run_persecond(times=times, temperatures=temps, domains=demo.domains, targets=target,
+        #                    epsilon=epsilon, simulation=simulation)
+
+        return demo
+
+    try:
+        return _(ndoms, energies, fractions), True
+    except OverEpsilonError as e:
+        if ignore_error:
+            return demo, False
+        else:
+            raise
+
+
+def run_40ar(times, temps, statuses, energies, fractions, ndoms: int = 1, grain_szie=275, atom_density=1e10, frequency=1e13,
         dimension: int = 3, targets: list = None, epsilon: float = 0.001, simulation: bool = False,
         file_name: str = "Y70", ignore_error: bool = False, **kwargs):
     """

ararpy/thermo/basic.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2025 Yang 
+# ararpy - basic
+# ==========================================
+#
+#
+# 
+"""
+import numpy as np
+from math import log
+
+SEC2YEAR = 3600 * 24 * 365.2425
+CAL2JOULE = 4.184
+CM2UM = 10000
+GAS_CONSTANT = 8.31446261815324  # in J / (mol K)
+
+
+def gammq(a, x):
+    if x < 0 or a <= 0:
+        raise ValueError("ERROR(GAMMQ): x < 0 or a <= 0")
+
+    if x < a + 1:
+        gamser, gln = gser(a, x)
+        return 1.0 - gamser
+    else:
+        gammcf, gln = gcf(a, x)
+        return gammcf
+
+def gser(a, x, itmax=100, eps=3e-7):
+    gln = gammln(a)
+    if x <= 0:
+        if x < 0:
+            raise ValueError("ERROR(GSER): x < 0")
+        return 0.0, gln
+
+    ap = a
+    sum_ = 1.0 / a
+    delta = sum_
+    for n in range(1, itmax + 1):
+        ap += 1
+        delta *= x / ap
+        sum_ += delta
+        if abs(delta) < abs(sum_) * eps:
+            break
+    else:
+        raise RuntimeError("ERROR(GSER): a too large, itmax too small")
+
+    gamser = sum_ * np.exp(-x + a * np.log(x) - gln)
+    return gamser, gln
+
+def gcf(a, x, itmax=100, eps=3e-7):
+    gln = gammln(a)
+    gold = 0.0
+    a0 = 1.0
+    a1 = x
+    b0 = 0.0
+    b1 = 1.0
+    fac = 1.0
+    for n in range(1, itmax + 1):
+        an = float(n)
+        ana = an - a
+        a0 = (a1 + a0 * ana) * fac
+        b0 = (b1 + b0 * ana) * fac
+        anf = an * fac
+        a1 = x * a0 + anf * a1
+        b1 = x * b0 + anf * b1
+        if a1 != 0:
+            fac = 1.0 / a1
+            g = b1 * fac
+            if abs((g - gold) / g) < eps:
+                return g * np.exp(-x + a * np.log(x) - gln), gln
+            gold = g
+    else:
+        raise RuntimeError("ERROR(GCF): a too large, itmax too small")
+
+def gammln(xx):
+    cof = np.array([76.18009173, -86.50532033, 24.01409822,
+                    -1.231739516, 0.00120858003, -0.00000536382])
+    stp = 2.50662827465
+    half = 0.5
+    one = 1.0
+    fpf = 5.5
+
+    x = xx - one
+    tmp = x + fpf
+    tmp = (x + half) * np.log(tmp) - tmp
+    ser = one
+    for j in range(6):
+        x += one
+        ser += cof[j] / x
+
+    return tmp + np.log(stp * ser)
+
+
+def fit(x, y, sigx, sigy, pho=None):
+    """
+    equivalent to York2 regression
+    y = a + bx
+
+    Parameters
+    ----------
+    x
+    y
+    sigx
+    sigy
+    pho
+
+    Returns
+    -------
+    a: intercept
+    b: slope
+    siga: intercept uncertainty
+    sigb: slope uncertainty
+    chi2: chi-square value
+    q: the incomplete gamma function value, should be large for the best fitting.
+
+    """
+
+    print(f"{x = }")
+    print(f"{y = }")
+    print(f"{sigx = }")
+    print(f"{sigy = }")
+    print(f"{pho = }")
+
+    ndata = len(x)
+    if pho is None:
+        pho = np.zeros(ndata)
+    nd = 20
+    imax = 20
+    xerr = 0.001
+    wt = []
+    a = 0
+    b = -1.
+    siga = 0
+    sigb = 0
+    chi2 = 0
+    q = 0
+    iter = 0
+
+    while iter <= imax:
+        sx = 0.
+        sy = 0.
+        st2 = 0.
+        st3 = 0.
+        ss = 0.
+        b0 = b
+
+        for i in range(ndata):
+            wt.append(0)
+            wt[i] = 1. / (sigy[i] ** 2 + b ** 2 * sigx[i] ** 2 - 2 * pho[i] * sigx[i] * sigy[i])
+            ss = ss + wt[i]
+            sx = sx + x[i] * wt[i]
+            sy = sy + y[i] * wt[i]
+
+            # print(f"{x[i] = }, {y[i] = }, {wt[i] = }")
+
+        sxoss = sx / ss
+        syoss = sy / ss
+
+        for i in range(ndata):
+            t1 = (x[i] - sxoss) * sigy[i] ** 2
+            t2 = (y[i] - syoss) * sigx[i] ** 2 * b
+            t3 = sigx[i] * sigy[i] * pho[i]
+            st2 = st2 + wt[i] ** 2 * (y[i] - syoss) * (t1 + t2 - t3 * (y[i] - syoss))
+            st3 = st3 + wt[i] ** 2 * (x[i] - sxoss) * (t1 + t2 - b * t3 * (x[i] - sxoss))
+
+        b = st2 / st3
+        iter = iter + 1
+
+        # print(f"{sxoss = }, {syoss = }, {b = }, {abs(b0 - b) = }")
+
+        if abs(b0 - b) > xerr:
+            continue
+
+        a = (syoss - sxoss * b)
+        # print(f"{a = }, {b = }")
+        sgt1 = 0.
+        sgt2 = 0.
+
+        for i in range(ndata):
+            sgt1 = sgt1 + wt[i] * (x[i] - sxoss) ** 2
+            sgt2 = sgt2 + wt[i] * x[i] ** 2
+
+        sigb = (1. / sgt1) ** 0.5
+        siga = sigb * (sgt2 / ss) ** 0.5
+        chi2 = 0.
+
+        for i in range(ndata):
+            chi2 = chi2 + wt[i] * (y[i] - a - b * x[i]) ** 2
+
+        q = gammq(0.5 * (ndata - 2), 0.5 * chi2)
+
+        if abs(b0 - b) <= xerr:
+            break
+
+    return a, b, siga, sigb, chi2, q
+
+
+def get_tc(da2, sda2, E, sE, cooling_rate=10, temp_in_celsius=True, temp=None, A: float = 27.0, R=None, pho=0):
+    """
+    E / (R Tc) = ln(A t D0/a2)
+    E: diffusion activation energy
+    R: gas constant, 8.314 J/(K*mol)
+    Tc: closure temperature
+    A: geometric constant, A is 55, 27, or 8.7 for volume diffusion from a sphere, cylinder or plane sheet respectively
+    tau: time constant, can be determined by
+        (1) a pre-defined cooling rate following t = -R Tc2 / E * dT / dt, where dT / dt is the average cooling rate of the local geological body
+        (2) the age of dated sample following t = R * age * E * (Tp - Tc), where Tp is the temperature at present that could be 300 K.
+    D0: the diffusion coefficient at the given temperature, which will be the frequency factor (the pre-exponential factor) whe the temperature is infinite high
+    a: the effective diffusion radius, the characteristic dimension of the system, or the domain size, or roughly the grain size
+
+
+    In either way of them, a equation with Tc in both right and left hand will be yielded. Then using iterative calculation, the Tc can be determined.
+
+    Parameters
+    -------
+    da2: D/a2 in 1/a, pear year
+    sda2:
+    E: diffusion activation energy
+    sE:
+    pho: covariance of da2 and E
+    temp: temperature of the given diffusion coefficient, in K
+    A: geometric constant
+    R: gas constant
+    cooling_rate: in degree/m.y., degrees per million year
+    temp_in_celsius: temperature in celsius, True, else in K, False
+
+    Returns
+    -------
+
+    """
+    R = 8.314 if R is None else R # in J/K mol
+    Tc = 600
+    sTc = 0
+    Tm = 99999999 if temp is None else temp
+    Tm = Tm + 273.15 if temp_in_celsius else Tm
+    cooling_rate = cooling_rate / 1000000
+
+    iter_num = 0
+    iter_diff = 100
+    while abs(iter_diff) > 0.01 and iter_num < 100:
+        tau = R * Tc ** 2 / (E * cooling_rate)
+        # new_Tc = (E/R) / log(A * tau * da2)
+        new_Tc = (R / E) * log(A * tau * da2) + 1 / Tm  #
+        d1 = cooling_rate / (A * da2 * Tc ** 2)
+        s1 = d1 ** 2 * sda2 ** 2  # da2
+        d2 = R / E ** 2 * (log(A * tau * da2) + 1)
+        s2 = d2 ** 2 * sE ** 2  # E
+        d3 = 2 * R / (E * Tc)
+        s3 = d3 ** 2 * sTc ** 2  # Tc
+        new_Tc = 1 / new_Tc
+        iter_diff = abs(new_Tc - Tc)
+        Tc = new_Tc
+        sTc = Tc ** 2 * np.sqrt(s1 + s2 + s3 + 2 * d1 * d2 * pho)
+        iter_num += 1
+        # print(f"Get Tc: {iter_num = }, {Tc = }, {tau = }, {Tm = }")
+    return Tc - 273.15 if temp_in_celsius else Tc, sTc
+
+
+if __name__ == "__main__":
+    """
+    tests
+    """
+    # 柴田贤, 钾长石
+    print("# 柴田贤, 钾长石")
+    print(get_tc(da2=5.6 * 3600 * 24 * 365.24, sda2=0, E=28.8 * 1000, R=1.987, sE=0, cooling_rate=5, A=8.7))
+    print(get_tc(da2=5.6 * 3600 * 24 * 365.24, sda2=0, E=28.8 * CAL2JOULE * 1000, sE=0, cooling_rate=5, A=8.7))
+    print(get_tc(da2=5.6 * 3600 * 24 * 365.24, sda2=0, E=28.8 * CAL2JOULE * 1000, sE=0, cooling_rate=30, A=8.7))
+    # 杨静, 斜钾铁矾 K101-1
+    print("# 杨静, 斜钾铁矾 K101-1")
+    print(get_tc(da2=10 ** 15.07 * 3600 * 24 * 365.24, sda2=0, E=76.17 * 1000 * CAL2JOULE, sE=0, cooling_rate=5, A=55))  # 这里跟文章中吻合
+    print(get_tc(da2=10 ** 15.07 * 3600 * 24 * 365.24, sda2=0, E=76.17 * 1000 * CAL2JOULE, sE=0, cooling_rate=10, A=55))  # 10冷却速率不吻合
+    # 杨静, 斜钾铁矾 K101-2
+    print("# 杨静, 斜钾铁矾 K101-2")
+    print(get_tc(da2=10 ** 12.35 * 3600 * 24 * 365.24, sda2=0, E=66.43 * 1000 * CAL2JOULE, sE=0, cooling_rate=5, A=55))  # 这里跟文章中吻合
+    print(get_tc(da2=10 ** 12.35 * 3600 * 24 * 365.24, sda2=0, E=66.43 * 1000 * CAL2JOULE, sE=0, cooling_rate=10, A=55))  # 10冷却速率不吻合
+    # 芦武长
+    print("# 芦武长")
+    print(get_tc(da2=3e-4 * 3600 * 24 * 365.24, sda2=0, E=35 * 1000 * CAL2JOULE, sE=0, cooling_rate=0.1, A=27, temp=600))  # 缺乏样品特征尺寸参数，da2不对，结果不对
+    print(get_tc(da2=3e-4 * 3600 * 24 * 365.24, sda2=0, E=35 * 1000 * CAL2JOULE, sE=0, cooling_rate=1, A=27, temp=600))  # 缺乏样品特征尺寸参数，da2不对，结果不对
+    # Harrison 1981, 角闪石, A = 55
+    print("# Harrison 1981, 角闪石, A = 55")
+    print(get_tc(da2=0.024 * SEC2YEAR / 0.0080 ** 2, sda2=0, E=64.1 * 1000 * CAL2JOULE, sE=0, cooling_rate=500, A=55))
+    print(get_tc(da2=0.024 * SEC2YEAR / 0.0080 ** 2, sda2=0, E=64.1 * 1000 * CAL2JOULE, sE=0, cooling_rate=5, A=55))
+    # Harrison 1985, 黑云母, A = 27
+    print("# Harrison 1985, 黑云母, A = 27")
+    print(get_tc(da2=0.077 * SEC2YEAR / 0.0150 ** 2, sda2=0, E=47.0 * 1000 * CAL2JOULE, sE=0, cooling_rate=100, A=27))
+    print(get_tc(da2=0.077 * SEC2YEAR / 0.0150 ** 2, sda2=0, E=47.0 * 1000 * CAL2JOULE, sE=0, cooling_rate=1, A=27))
+    print("# Blereau 2019, 大隅石，Osumilite, A = 8.7")
+    print(get_tc(da2=8.34e8 * SEC2YEAR / (0.0175 ** 2), sda2=0, E=461 * 1000, sE=0, cooling_rate=10, A=8.7))
+    print(get_tc(da2=6.70e8 * SEC2YEAR / (0.0175 ** 2), sda2=0, E=453 * 1000, sE=0, cooling_rate=10, A=8.7))  # 这两个与原文对不上，且原文描述表格与文字不符
+    print(get_tc(da2=4.49e5 * SEC2YEAR / (0.0175 ** 2), sda2=0, E=369 * 1000, sE=0, cooling_rate=10, A=8.7))  # 这两个与原文对不上，且原文描述表格与文字不符
+    print("# Thern 2020, 电气石, A = 55")  # 大部分都对或者接近，不完全一致的原因大概是他们采用蒙特卡洛方法计算且正负误差不一样
+    print(get_tc(da2=4.86e22 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=678 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=8.99e23 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=756 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=3.95e19 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=604 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=6.95e27 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=815 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=2.70e14 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=519 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=1.65e15 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=505 * 1000, sE=0, cooling_rate=10, A=55))
+    print(get_tc(da2=9.09e21 * SEC2YEAR / (0.0100 ** 2), sda2=0, E=656 * 1000, sE=0, cooling_rate=10, A=55))
+    print("# Shi 2020, 黑云母, A = 55")  # 大部分都对或者接近，不完全一致的原因大概是他们采用蒙特卡洛方法计算且正负误差不一样
+    print(get_tc(da2=10 ** 18 * SEC2YEAR, sda2=0, E=87 * 1000 * CAL2JOULE, sE=0, cooling_rate=10, A=6))  # 文中的参数可能是cooling_rate=100, A=8.7，但是10和6的组合与文中报导的结果一致
+    print(get_tc(da2=10 ** 16.6 * SEC2YEAR, sda2=0, E=81.5 * 1000 * CAL2JOULE, sE=0, cooling_rate=10, A=6))