ararpy 0.0.1a1__py3-none-any.whl

ararpy/__init__.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# webarar - __init__.py
+# ==========================================
+#
+# ArArPy
+#
+"""
+import os
+
+import pandas as pd
+from . import calc, smp, files
+
+""" classes """
+Sample = smp.samples.Sample
+Info = smp.samples.Info
+Table = smp.samples.Table
+Plot = smp.samples.Plot
+Set = smp.samples.Plot.Set
+Label = smp.samples.Plot.Label
+Axis = smp.samples.Plot.Axis
+Text = smp.samples.Plot.Text
+
+
+class ArArBasic:
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+
+class ArArData(ArArBasic):
+    def __init__(self, **kwargs):
+        self.data: list = []
+        self.header: list = []
+        super().__init__(**kwargs)
+        if not isinstance(self.data, list):
+            raise TypeError(f"Data must be a list.")
+        if len(self.header) != len(self.data):
+            self.header = [*self.header, *list(range(len(self.header), len(self.data)))][:len(self.data)]
+
+    def to_df(self) -> pd.DataFrame: return pd.DataFrame(self.data, index=self.header).transpose()
+    def to_list(self) -> list: return self.data
+
+
+""" information for ararpy """
+name = 'ararpy'
+version = '0.0.1.a1'
+__version__ = version
+full_version = version
+last_update = '2023-12-17'
+
+""" functions and attributions for ararpy """
+from_arr = files.arr_file.to_sample
+from_age = files.calc_file.to_sample
+from_full = files.calc_file.full_to_sample
+from_empty = files.new_file.to_sample
+
+""" define functions and attributions for Sample class """
+Sample.name = lambda _smp: _smp.Info.sample.name
+Sample.doi = lambda _smp: _smp.Doi
+Sample.sample = lambda _smp: _smp.Info.sample
+Sample.researcher = lambda _smp: _smp.Info.researcher
+Sample.laboratory = lambda _smp: _smp.Info.laboratory
+
+Sample.results = lambda _smp: ArArBasic(
+    isochron=ArArBasic(**dict(
+        (
+            {
+                'figure_2': 'normal', 'figure_3': 'inverse', 'figure_4': 'cl_1',
+                'figure_5': 'cl_2', 'figure_6': 'cl_3', 'figure_7': 'three_d'
+            }[key],
+            ArArBasic(
+                **dict(
+                    (
+                        {2: 'unselected', 0: 'set1', 1: 'set2'}[_key],
+                        ArArBasic(**_value)
+                    ) for (_key, _value) in value.items()
+                )
+            )
+        ) for (key, value) in _smp.Info.results.isochron.items())),
+    age_plateau=ArArBasic(
+        **dict(({2: 'unselected', 0: 'set1', 1: 'set2'}[key], ArArBasic(**value))
+               for (key, value) in _smp.Info.results.age_plateau.items()))
+)
+Sample.sequence = lambda _smp: ArArBasic(
+    size=len(_smp.SequenceName), name=_smp.SequenceName,
+    value=_smp.SequenceValue, unit=_smp.SequenceUnit,
+    mark=ArArBasic(
+        size=len(_smp.IsochronMark),
+        set1=ArArBasic(
+            size=sum([1 if i == 1 else 0 for i in _smp.IsochronMark]),
+            index=[index for index, _ in enumerate(_smp.IsochronMark) if _ == 1],
+        ),
+        set2=ArArBasic(
+            size=sum([1 if i == 2 else 0 for i in _smp.IsochronMark]),
+            index=[index for index, _ in enumerate(_smp.IsochronMark) if _ == 2],
+        ),
+        unselected=ArArBasic(
+            size=sum([0 if i == 2 or i == 1 else 1 for i in _smp.IsochronMark]),
+            index=[index for index, _ in enumerate(_smp.IsochronMark) if _ != 1 and _ != 2],
+        ),
+        value=_smp.IsochronMark,
+    )
+)
+
+Sample.initial = smp.initial.initial
+Sample.set_selection = lambda _smp, _index, _mark: smp.plots.set_selection(_smp, _index, _mark)
+Sample.update_table = lambda _smp, _data, _id: smp.table.update_handsontable(_smp, _data, _id)
+
+Sample.unknown = lambda _smp: ArArData(
+    name='unknown', data=_smp.SampleIntercept
+)
+Sample.blank = lambda _smp: ArArData(
+    name='blank', data=_smp.BlankIntercept
+)
+Sample.parameters = lambda _smp: ArArData(
+    name='parameters', data=_smp.TotalParam
+)
+Sample.corrected = lambda _smp: ArArData(
+    name='parameters', data=_smp.CorrectedValues
+)
+Sample.degas = lambda _smp: ArArData(
+    name='parameters', data=_smp.DegasValues
+)
+Sample.isochron = lambda _smp: ArArData(
+    name='isochron', data=_smp.IsochronValues
+)
+Sample.apparent_ages = lambda _smp: ArArData(
+    name='apparent_ages', data=_smp.ApparentAgeValues
+)
+Sample.publish = lambda _smp: ArArData(
+    name='publish', data=_smp.PublishValues
+)
+
+Sample.corr_blank = smp.corr.corr_blank
+Sample.corr_massdiscr = smp.corr.corr_massdiscr
+Sample.corr_decay = smp.corr.corr_decay
+Sample.corr_ca = smp.corr.calc_degas_ca
+Sample.corr_k = smp.corr.calc_degas_k
+Sample.corr_cl = smp.corr.calc_degas_cl
+Sample.corr_atm = smp.corr.calc_degas_atm
+Sample.corr_r = smp.corr.calc_degas_r
+Sample.calc_ratio = smp.corr.calc_ratio
+
+Sample.recalculate = lambda _smp, **kwargs: smp.calculation.recalculate(_smp, **kwargs)
+
+Sample.show_data = lambda _smp: \
+    f"Sample Name: \n\t{_smp.name()}\n" \
+    f"Doi: \n\t{_smp.doi()}\n" \
+    f"Corrected Values: \n\t{_smp.corrected().to_df()}\n" \
+    f"Parameters: \n\t{_smp.parameters().to_df()}\n" \
+    f"Isochron Values: \n\t{_smp.isochron().to_df()}\n" \
+    f"Apparent Ages: \n\t{_smp.apparent_ages().to_df()}\n" \
+    f"Publish Table: \n\t{_smp.publish().to_df()}\n"
+
+__tab = "\t"
+Sample.help = f"" \
+              f"builtin methods:\n " \
+              f"{__tab.join([func for func in dir(Sample) if callable(getattr(Sample, func)) and func.startswith('__')])}\n" \
+              f"dunder-excluded methods:\n " \
+              f"{__tab.join([func for func in dir(Sample) if callable(getattr(Sample, func)) and not func.startswith('__')])}\n"
+
+
+def test():
+    example_dir = os.path.join(os.getcwd(), r'examples')
+    print(f"Running: ararpy.test()")
+    print(f"============= Open an example .arr file =============")
+    file_path = os.path.join(example_dir, r'22WHA0433.arr')
+    print(f"{file_path = }")
+    print(f"sample = from_arr(file_path=file_path)")
+    sample = from_arr(file_path=file_path)
+    print(f"{sample.name() = }")
+    print(f"{sample.help = }")
+    print(f"sample.parameters() = {sample.parameters()}")
+    print(f"sample.parameters().to_df() = \n{sample.parameters().to_df()}")

ararpy/calc/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - __init__.py
+# ==========================================
+"""
+
+from . import arr, err, spectra, isochron, regression, age, plot, basic, \
+    histogram, corr, jvalue, raw_funcs

ararpy/calc/age.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - age
+# ==========================================
+#
+#
+#
+"""
+
+# === Internal import ===
+from . import arr
+
+# === External import ===
+import numpy as np
+
+
+def calc_age_min(F, sF, **kwargs) -> tuple:
+    """
+    Calculate ArAr ages using Min et al. (2000) equation.
+    Parameters
+    ----------
+    F : array-like
+    sF : array-like
+    kwargs :
+         keys : [
+            'F', 'sF', 'L', 'sL', 'Le', 'sLe', 'Lb', 'sLb', 'A', 'sA', 'Ae', 'sAe', 'Ab', 'sAb',
+            't', 'st', 'J', 'sJ', 'W', 'sW', 'No', 'sNo', 'Y', 'sY', 'f', 'sf', 'Min'
+        ].
+        values :  array-like objects.
+
+    Returns
+    -------
+
+    """
+    """
+    
+    kwargs keys:     [
+        'F', 'sF', 'L', 'sL', 'Le', 'sLe', 'Lb', 'sLb', 'A', 'sA', 'Ae', 'sAe', 'Ab', 'sAb',
+        't', 'st', 'J', 'sJ', 'W', 'sW', 'No', 'sNo', 'Y', 'sY', 'f', 'sf', 'Min'
+    ]. values are array-like objects
+    :param F:
+    :param sF:
+    :param kwargs:
+    :return:
+    """
+    F, sF = arr.array_as_float([F, sF]).astype(float)
+    J = arr.array_as_float(kwargs.pop('J'))
+    sJ = arr.array_as_float(kwargs.pop('sJ') * J / 100)
+    A = arr.array_as_float(kwargs.pop('A'))
+    sA = arr.array_as_float(kwargs.pop('sA') * A / 100)
+    Ae = arr.array_as_float(kwargs.pop('Ae'))
+    sAe = arr.array_as_float(kwargs.pop('sAe') * Ae / 100)
+    Ab = arr.array_as_float(kwargs.pop('Ab'))
+    sAb = arr.array_as_float(kwargs.pop('sAb') * Ab / 100)
+    W = arr.array_as_float(kwargs.pop('W'))
+    sW = arr.array_as_float(kwargs.pop('sW') * W / 100)
+    Y = arr.array_as_float(kwargs.pop('Y'))
+    sY = arr.array_as_float(kwargs.pop('sY') * Y / 100)
+    f = arr.array_as_float(kwargs.pop('f'))
+    sf = arr.array_as_float(kwargs.pop('sf') * f / 100)
+    No = arr.array_as_float(kwargs.pop('No'))
+    sNo = arr.array_as_float(kwargs.pop('sNo') * No / 100)
+    L = arr.array_as_float(kwargs.pop('L'))
+    sL = arr.array_as_float(kwargs.pop('sL') * L / 100)
+    Le = arr.array_as_float(kwargs.pop('Le'))
+    sLe = arr.array_as_float(kwargs.pop('sLe') * Le / 100)
+    Lb = arr.array_as_float(kwargs.pop('Lb'))
+    sLb = arr.array_as_float(kwargs.pop('sLb') * Lb / 100)
+    t = arr.array_as_float(kwargs.pop('t'))
+    st = arr.array_as_float(kwargs.pop('st') * t / 100)
+    # Ap = arr.array_as_float(kwargs.pop('Ap'))
+    # sAp = arr.array_as_float(kwargs.pop('sAp') * Ap / 100)
+    # Kp = arr.array_as_float(kwargs.pop('Kp'))
+    # sKp = arr.array_as_float(kwargs.pop('sKp') * Kp / 100)
+
+    # recalculation using Min et al.(2000) equation
+    # lmd = A * W * Y / (f * No)
+    V = f * No / ((Ab + Ae) * W * Y)
+    sf = 0  # the error of f was not considered by Koppers
+    sV = pow((V / f * sf) ** 2 + (V / No * sNo) ** 2 + (V / (Ab + Ae)) ** 2 * (sAb ** 2 + sAe ** 2) +
+             (V / W * sW) ** 2 + (V / Y * sY) ** 2, 0.5)
+    # standard age in year, change to Ma
+    t = t * 1000000
+    st = st * 1000000
+    # back-calculating Ar40/Ar39 ration for the standard
+    stdR = (np.exp(t * L) - 1) / J
+    # errors of standard age and decay constants were not applied
+    sStdR = pow((stdR / J) ** 2 * sJ ** 2, 0.5)
+    # normalize the measured 40Ar/39Ar
+    R = F / stdR
+    sR_1 = np.sqrt((sF / stdR) ** 2 + (F * sStdR / stdR ** 2) ** 2)  # errors of measured 40Ar/39Ar and J value
+    sR_2 = np.sqrt((sF / stdR) ** 2)  # error of measured 40Ar/39Ar only
+
+    BB = 1
+    KK = np.exp(t / V) - 1  # 40Arr / 40K Use standard age
+    XX = BB * KK * R + 1
+    k0 = V * np.log(XX)
+    e1 = (np.log(XX) * V / f - V * BB * KK * R / (f * XX)) ** 2 * sf ** 2  # sFr
+    e2 = (np.log(XX) * V / No) ** 2 * sNo ** 2  # sNo
+    e3 = (-1 * np.log(XX) * V / A + BB * KK * R / (A * XX)) ** 2 * sAb ** 2  # sAb
+    e4 = (-1 * np.log(XX) * V / A - Ab * KK * R / (Ae ** 2 * XX)) ** 2 * sAe ** 2  # sAe
+    e5 = (-1 * np.log(XX) * V / W - V * BB * KK * R / (W * XX)) ** 2 * sW ** 2  # sW
+    e6 = (np.log(XX) * V / Y) ** 2 * sY ** 2  # sY
+    e7 = (V * BB * KK / XX) ** 2 * sR_1 ** 2  # sR
+    # e8 = (V * BB * KK * R / (Ap * XX)) ** 2 * sAp ** 2  # sAp
+    # e9 = (V * BB * KK * R / (Kp * XX)) ** 2 * sKp ** 2  # sKp
+    e8, e9 = 0, 0
+    useDecayConst = False
+    if useDecayConst:  # k0 = log(L / Le * KK * R + 1) / L
+        e1 = (V * BB * KK * R / (f * XX)) ** 2 * sf ** 2
+        e2 = 0
+        e3 = (-1 * np.log(XX) * V / L + BB * KK * R / (L * XX)) ** 2 * sLb ** 2
+        e4 = (-1 * np.log(XX) * V / L - Lb * KK * R / (Le ** 2 * XX)) ** 2 * sLe ** 2
+        e5 = (V * BB * KK * R / (W * XX)) ** 2 * sW ** 2
+        e6 = 0
+    useStandardAge = True
+    if useStandardAge:
+        e1, e9 = 0, 0
+
+    # change to Ma
+    # analytical error, error of 40Ar/39Ar only
+    s1 = np.sqrt((V * KK * R / (R * XX)) ** 2 * sR_2 ** 2) / 1000000
+    # internal error, errors of 40Ar/39Ar and J value
+    s2 = np.sqrt((V * KK * R / (R * XX)) ** 2 * sR_1 ** 2) / 1000000
+    # total external error
+    s3 = np.sqrt(e1 + e2 + e3 + e4 + e5 + e6 + e7 + e8 + e9) / 1000000
+    age = k0 / 1000000
+    return age, s1, s2, s3
+
+
+def calc_age_general(F, sF, J, sJ, L, sL, **kwargs):
+    """
+    All passed args should be array-like with the same length
+    Parameters
+    ----------
+    F : array-like object
+    sF : array-like object
+    J : array-like object
+    sJ : array-like object
+    L : array-like object
+    sL : array-like object
+    kwargs
+
+    Returns
+    -------
+    tuple of array objects, (age, s1, s2, s3)
+    """
+    F, sF, J, sJ, L, sL = np.array([F, sF, J, sJ, L, sL])
+    sJ = sJ * J / 100
+    sL = sL * L / 100
+    age = np.log(1 + J * F) / L
+    v1 = sF ** 2 * (J / (L * (1 + J * F))) ** 2
+    v2 = sJ ** 2 * (F / (L * (1 + J * F))) ** 2
+    v3 = sL ** 2 * (np.log(1 + J * F) / (L ** 2)) ** 2
+    s1 = v1 ** .5  # analytical error
+    s2 = (v1 + v2) ** .5  # internal error
+    s3 = (v1 + v2 + v3) ** .5  # full external error
+    return age / 1000000, s1 / 1000000, s2 / 1000000, s3 / 1000000