ararpy 0.1.199__py3-none-any.whl → 0.2.2__py3-none-any.whl

ararpy/smp/diffusion_funcs.py

@@ -56,7 +56,10 @@ class DiffSample:
 
         if smp is not None:
             self.smp = smp
-            self.sname = self.smp.name()
+            if name is None:
+                self.sname = self.smp.name()
+            else:
+                self.sname = name
 
             self.sequence = self.smp.sequence()
             self.ni = self.sequence.size  # sequence number
@@ -76,7 +79,7 @@ class DiffSample:
             self.ya = np.array(self.smp.ApparentAgeValues[2], dtype=np.float64)
             self.sig = np.array(self.smp.ApparentAgeValues[3], dtype=np.float64)
 
-            read_from_file = kwargs.get('read_from_file', False)
+            read_from_file = kwargs.get('read_from_file', True)
             if read_from_file:
                 self.file_age_in = open(os.path.join(self.loc, f"{self.sname}_age.in"), "w")
                 self.file_sig_in = open(os.path.join(self.loc, f"{self.sname}_sig.in"), "w")
@@ -125,6 +128,11 @@ class DiffArrmultiFunc(DiffSample):
 
         self.file_output_par = open(os.path.join(self.loc, f"{self.sname}.par"), "w")
         self.file_output_ame = open(os.path.join(self.loc, f"{self.sname}.ame"), "w")
+
+        self.file_output_ar0 = open(os.path.join(self.loc, f"{self.sname}.ar0"), "w")
+        self.file_output_ar1 = open(os.path.join(self.loc, f"{self.sname}.ar1"), "w")
+        self.file_output_lg0 = open(os.path.join(self.loc, f"{self.sname}.lg1"), "w")
+        self.file_output_lg1 = open(os.path.join(self.loc, f"{self.sname}.lg1"), "w")
         # self.file_output_mch = open(os.path.join(self.loc, f"{self.sname}_mch-out.dat"), "w")
         # self.file_output_mages = open(os.path.join(self.loc, f"{self.sname}_mages-out.dat"), "w")
         # self.file_output_agesd = open(os.path.join(self.loc, f"{self.sname}_ages-sd.samp"), "w")
@@ -143,6 +151,7 @@ class DiffArrmultiFunc(DiffSample):
         self.f = [0]  # ar39%, array(ni)
         self.a39 = []  # ar39, array(ni - 1)
         self.sig39 = []  # sigma of ar39, array(ni - 1)
+        self.max_temp = 1373  # in K, 1100°C + 273
 
         # for i in range(self.ni):
         #     self.telab.append(float(self.file_tmp_in.readline()))  # heating temperature in Kelvin
@@ -202,14 +211,19 @@ class DiffArrmultiFunc(DiffSample):
         # xlogd = [np.log10((dtr2[i + 1] - dtr2[i]) / self.tilab[i] * self.imp ** 2) for i in range(0, len(dtr2) - 1)]
         xlogd = self.xlogd
         tinv = [1 / i * 10000 for i in self.telab]
+
         self.nimax = self.ni  # the first sequence index great than 1100 celsius degree
         for i in range(self.ni):
-            if self.nimax == self.ni and self.telab[i] > 1373:
+            if self.nimax == self.ni and self.telab[i] > self.max_temp:
                 self.nimax = i
 
         # wt = self.errcal()
         wt = self.wt
 
+        for i in range(len(xlogd)):
+            self.file_output_ar0.writelines(f"{tinv[i]}\t{xlogd[i]}\t{wt[i]}\n")
+        self.file_output_ar0.close()
+
         wf = []
         sumwf = 0
         for i in range(self.ni):
@@ -231,7 +245,6 @@ class DiffArrmultiFunc(DiffSample):
 
         slop = e * ee / (r * 10000)
         xro = (ordi - slop * tinv[self.nimax - 1] - xlogd[self.nimax - 1]) / 2 * (1 + (1 - self.f[self.nimax]) / 2)
-
         e0 = e
         ord0 = ordi
         self.ni = self.nimax
@@ -240,7 +253,7 @@ class DiffArrmultiFunc(DiffSample):
 
         nca = 20
         zi = [0]
-        ndom = 8
+        ndom = self.ndom
         na = 2 * ndom - 1
         a1 = np.zeros(na + 1, dtype=np.float64)
         a2 = np.zeros(na + 1, dtype=np.float64)
@@ -273,7 +286,6 @@ class DiffArrmultiFunc(DiffSample):
         to_break = False
 
         while True:
-
             nnnnnn += 1
 
             a1, a2 = self.guess(ndom, a1, a2, xro, self.generator.idum)
@@ -436,8 +448,8 @@ class DiffArrmultiFunc(DiffSample):
                         mct += 1
                         continue
 
-                    fmod = np.zeros(ns, dtype=np.float64)
-                    for nt in range(self.ni):
+                    fmod = np.zeros(ns+1, dtype=np.float64)
+                    for nt in range(1, self.ni+1):
                         y, dyda = self.funcs(zi[nt], a2, na, a1)
                         fmod[nt] = y
                         if amax == -1:
@@ -480,8 +492,17 @@ class DiffArrmultiFunc(DiffSample):
                     self.file_output_ame.writelines(f"{slop}\n")
                     self.file_output_ame.writelines(f"{ordi}\n")
 
+
                     dzx = np.zeros(ns, dtype=np.float64)
-                    dzx, _ = self.arr(e, ordi, dzx, fmod, self.f, self.telab, self.tilab, xlogd)
+                    dzx, _ , results_16, results_18, results_22 = self.arr(e, ordi, dzx, fmod, self.f, self.telab, self.tilab, xlogd)
+
+                    for each_line in results_16:
+                        self.file_output_ar1.writelines(f"{each_line}\n")
+                    for each_line in results_18:
+                        self.file_output_lg1.writelines(f"{each_line}\n")
+                    for each_line in results_22:
+                        self.file_output_lg0.writelines(f"{each_line}\n")
+
 
                     chisq2 = 0.
                     noutlier = 0
@@ -1462,9 +1483,9 @@ class DiffArrmultiFunc(DiffSample):
         # INVERSION OF 39-F
         for k in range(ni):
             if fmod[k] > acut:
-                zx[k + 1] = -np.log(pi ** 2 / b * (1.0 - fmod[k])) / pi ** 2
+                zx[k + 1] = -np.log(pi ** 2 / b * (1.0 - fmod[k+1])) / pi ** 2
             else:
-                zx[k + 1] = pi * (fmod[k] / 4.0) ** 2
+                zx[k + 1] = pi * (fmod[k+1] / 4.0) ** 2
 
         zx[0] = 0.0
         slop = e * ee / 10000.0 / r
@@ -1477,8 +1498,8 @@ class DiffArrmultiFunc(DiffSample):
             dzx[k] = np.log10((zx[k + 1] - zx[k]) / tilab[k] * imp ** 2)
             tinv = 1.0 / telab[k] * 10000.0
             xlog = (ord - slop * tinv - dzx[k]) / 2.0
-            results_18.append(f"{fmod[k - 1] * 100:.8f}{tab1}{xlog:.8f}")
             results_18.append(f"{fmod[k] * 100:.8f}{tab1}{xlog:.8f}")
+            results_18.append(f"{fmod[k+1] * 100:.8f}{tab1}{xlog:.8f}")
             results_16.append(f"{tinv:.8f}{tab1}{dzx[k]:.8f}")
 
         results_16.append("&")
@@ -1487,10 +1508,11 @@ class DiffArrmultiFunc(DiffSample):
         for k in range(ni):
             tinv = 1.0 / telab[k] * 10000.0
             xlogr0 = (ord - slop * tinv - xlogd[k]) / 2.0
-            results_22.append(f"{f[k - 1] * 100:.8f}{tab1}{xlogr0:.8f}")
             results_22.append(f"{f[k] * 100:.8f}{tab1}{xlogr0:.8f}")
+            results_22.append(f"{f[k+1] * 100:.8f}{tab1}{xlogr0:.8f}")
+
 
-        return dzx, zx
+        return dzx, zx, results_16, results_18, results_22
 
 
 class DiffAgemonFuncs(DiffSample):
@@ -1631,6 +1653,7 @@ class DiffAgemonFuncs(DiffSample):
 
         ###
         # initialize
+        print(f"DiffAgemon initializing ...")
         lista = np.zeros(self.nc, dtype=int)
         c0 = np.zeros(self.nc, dtype=np.float64)
         c = np.zeros(self.nc, dtype=np.float64)
@@ -4225,7 +4248,7 @@ def gammln(xx):
 
 
 
-def conf(input_x, input_y, count=None, num=None, using_binom=False, using_normal=False):
+def conf(input_x, input_y, count=None, num=None, using_binom=False, using_normal=False, start=None, end=None):
     """
     Calculate 90% confident interval of the given distribution of cooling histories.
     Parameters
@@ -4239,6 +4262,37 @@ def conf(input_x, input_y, count=None, num=None, using_binom=False, using_normal
 
     """
 
+    if len(input_x) != len(input_y):
+        raise ValueError("length of input x does not equal to that of input y")
+
+    data_length = len(input_x)
+    if start is None:
+        start = min([min(i) for i in input_x])
+    if end is None:
+        end = max([max(i) for i in input_x])
+    num = 20 if num is None else num
+
+    x_conf = np.linspace(start, end, num=num).tolist()
+    y1_conf = []
+    y2_conf = []
+    y3_conf = []
+    y4_conf = []
+    y_conf = np.zeros((num, data_length)).tolist()
+    #
+    # # distribution
+    # for k, out_x in enumerate(x_conf):
+    #     for i in range(data_length):
+    #         xs = input_x[i]
+    #         ys = input_y[i]
+    #         out_y = 0
+    #         for j, xi in enumerate(xs):
+    #             if xi <= out_x <= xs[j+1]:
+    #                 y_conf[k, i] = (ys[j+1] - ys[j]) / (xs[j+1] - xs[j]) * (out_x - xs[j]) + ys[j]
+    #                 break
+    #
+    # print(y_conf)
+
+
     input_x = np.array(input_x)
     input_y = np.array(input_y)
 
@@ -4253,12 +4307,6 @@ def conf(input_x, input_y, count=None, num=None, using_binom=False, using_normal
     x_steps_num = int(x_end - x_start) if num is None else num
     dx = (x_end - x_start) / x_steps_num
 
-    x_conf = []
-    y1_conf = []
-    y2_conf = []
-    y3_conf = []
-    y4_conf = []
-
     for i in range(x_steps_num + 1):
         data = []
         # 置信曲线的x，即age
@@ -4388,7 +4436,7 @@ def get_random_dir(path: str, length=7, random_index=""):
     try:
         exist_ok = random_index != ""
         if random_index == "":
-            random_index = calc.basic.get_random_digits(length=length)
+            random_index = calc.basic.random_choice(length=length)
         destination_folder = os.path.join(path, random_index)
         os.makedirs(destination_folder, exist_ok=exist_ok)
         return destination_folder, random_index
@@ -4442,18 +4490,18 @@ def run_agemon_dll(sample: Sample, source_dll_path: str, loc: str, data, max_age
     max_age = agemon.max_plateau_age  # double
     nsteps = agemon.ni  # int
 
-    # print(f"{xs = }")
-    # print(f"{age = }")
-    # print(f"{sig = }")
-    # print(f"{e = }")
-    # print(f"{d0 = }")
-    # print(f"{vc = }")
-    # print(f"{nsts = }")
-    # print(f"{temp = }")
-    # print(f"{heating_time = }")
-    # print(f"{kk = }")
-    # print(f"{max_age = }")
-    # print(f"{nsteps = }")
+    print(f"{xs = }")
+    print(f"{age = }")
+    print(f"{sig = }")
+    print(f"{e = }")
+    print(f"{d0 = }")
+    print(f"{vc = }")
+    print(f"{nsts = }")
+    print(f"{temp = }")
+    print(f"{heating_time = }")
+    print(f"{kk = }")
+    print(f"{max_age = }")
+    print(f"{nsteps = }")
 
     d0_flatten = d0.flatten()
     vc_flatten = vc.flatten()
@@ -4483,7 +4531,8 @@ def run_agemon_dll(sample: Sample, source_dll_path: str, loc: str, data, max_age
             ctypes.c_char_p(filepath),
             ctypes.c_char_p(samplename)
         )
-    except:
+    except Exception as e:
+        print(e)
         pass
     else:
         del mylib
@@ -4669,6 +4718,197 @@ def dr2_plane(f, ti, ar, sar, ln=True):
     return dr2, logdr2, wt
 
 
+def dr2_cylinder(f, ti, ar, sar, ln=True):
+    """
+
+    Cylinder model
+
+    Parameters
+    ----------
+    f
+    ti
+    ar
+    sar
+    ln
+
+    Returns
+    -------
+
+    """
+    f = np.array(f)
+    ti = np.array(ti)
+    n = min(len(f), len(ti))
+    ar = np.array(ar)
+    sar = np.array(sar)
+    sar2 = sar ** 2
+    ti = ti * 60  # in seconds
+    sti = [90 for i in range(n)]
+    pi = math.pi
+    pi = 3.141592654
+
+    # sf = sqrt(b ** 2 * siga ** 2 + a ** 2 * sigb ** 2) / (a + b) ** 2
+    # sf = [math.sqrt(sar[i + 1:].sum() ** 2 * (sar[:i + 1] ** 2).sum() + ar[:i + 1].sum() ** 2 * (sar[i + 1:] ** 2).sum()) / ar.sum() ** 2 for i in range(len(ar) - 1)]
+    # sf.append(0)
+
+    f = np.where(f >= 1, 0.9999999999999999, f)
+
+    model = geometric_model(geo='cylinder')
+    dtr2 = [model(bp=0.6)[1](fi) for fi in f]
+    dtr2_1 = [model(bp=0)[1](fi) for fi in f]
+    dtr2_2 = [model(bp=2)[1](fi) for fi in f]
+    dtr2_1.insert(0, 0); dtr2_2.insert(0, 0)
+    # dr2 = [(dtr2[i] - (dtr2[i - 1] if i > 0 else 0)) / ti[i] for i in range(len(dtr2))]
+    dr2 = [((dtr2_1[i+1] - dtr2_1[i]) / ti[i]) if f[i] > 0.6 else ((dtr2_2[i+1] - dtr2_2[i]) / ti[i]) for i in range(len(f))]
+
+    # imp = 2
+    # # imp = 1
+    # dtr2 = [pi * (fi / 4) ** 2 if fi <= 0.5 else math.log((1 - fi) * pi ** 2 / 8) / (- pi ** 2) for fi in f]
+    # dr2 = [(dtr2[i] - (dtr2[i - 1] if i > 0 else 0)) / ti[i] * imp ** 2 for i in range(len(dtr2))]
+    # xlogd = [np.log10(i) for i in dr2]
+
+    sar_lt = np.zeros(n)  # 偏导数
+    sar_eq = np.zeros(n)  # 偏导数
+    sar_gt = np.zeros(n)  # 偏导数
+    st = np.zeros(n)  # 偏导数
+    sdr2 = np.zeros(n)
+    for i in range(n):
+        if i == 0:
+            if f[i] <= 0.6:
+                sar_lt[i] = 0
+                sar_eq[i] = (1 / (ti[i] * (1 - f[i] / 4 * pi) ** 0.5)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - 1 / ti[i] * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+                sar_gt[i] = (1 / (ti[i] * (1 - f[i] / 4 * pi) ** 0.5)) * ((0 - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - 1 / ti[i] * ((0 - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+            else:
+                sar_lt[i] = 0
+                sar_eq[i] = (1 / (5.78 * ti[i] * (1 - f[i]))) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+                sar_gt[i] = (1 / (5.78 * ti[i] * (1 - f[i]))) * ((0 - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+        else:
+
+            if f[i] <= 0.6:
+                sar_lt[i] = (1 / (ti[i] * (1 - f[i] / 4 * pi) ** 0.5)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - (1 / (ti[i] * (1 - f[i-1] / 4 * pi) ** 0.5)) * ((sum(ar) - ar[i-1] - sum(ar[:i-1])) / sum(ar) ** 2) - (1 / ti[i]) * (0 - ar[i]) / sum(ar) ** 2
+                sar_eq[i] = (1 / (ti[i] * (1 - f[i] / 4 * pi) ** 0.5)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - (1 / (ti[i] * (1 - f[i-1] / 4 * pi) ** 0.5)) * ((0 - 0 - sum(ar[:i-1])) / sum(ar) ** 2) - (1 / ti[i]) * (sum(ar) - ar[i]) / sum(ar) ** 2
+                sar_gt[i] = (1 / (ti[i] * (1 - f[i] / 4 * pi) ** 0.5)) * ((0 - 0 - sum(ar[:i])) / sum(ar) ** 2) - (1 / (ti[i] * (1 - f[i-1] / 4 * pi) ** 0.5)) * ((0 - 0 - sum(ar[:i-1])) / sum(ar) ** 2) - (1 / ti[i]) * (0 - ar[i]) / sum(ar) ** 2
+            else:
+                sar_lt[i] = (1 / (5.78 * ti[i] * sum(ar[i:]) * sum(ar[i+1:]))) * (0 - 0)
+                sar_eq[i] = (1 / (5.78 * ti[i] * sum(ar[i:]) * sum(ar[i+1:]))) * (sum(ar[i+1:]) - 0)
+                sar_gt[i] = (1 / (5.78 * ti[i] * sum(ar[i:]) * sum(ar[i+1:]))) * (sum(ar[i+1:]) - sum(ar[i:]))
+                if i == n - 1:
+                    sar_lt[i] = 0
+                    sar_eq[i] = 0
+                    sar_gt[i] = 0
+        st[i] = - dr2[i] / ti[i]
+        sdr2[i] = math.sqrt(sar_lt[i] ** 2 * sum(sar2[:i]) + sar_eq[i] ** 2 * sar2[i] + sar_gt[i] ** 2 * sum(sar2[i+1:]) + st[i] ** 2 * sti[i] ** 2)
+
+    # wt = np.abs(sdr2 / dr2)
+    # wt = errcal(f, ti, ar, sar)
+
+    logdr2 = np.log(dr2) if ln else np.log10(dr2)
+    #ee = 1 / np.log(10)
+    ee = 0.4342944819
+    wt = np.abs(sdr2 / dr2) if ln else np.abs(sdr2 / dr2) * ee
+    #
+    # print(f"{wt = }")
+    # wt = errcal(f, ti, ar, sar)
+    # print(f"{wt = }")
+
+    return dr2, logdr2, wt
+
+
+def dr2_cube(f, ti, ar, sar, ln=True):
+    """
+
+    Cube model
+
+    Parameters
+    ----------
+    f
+    ti
+    ar
+    sar
+    ln
+
+    Returns
+    -------
+
+    """
+    # Lovera
+    f = np.array(f)
+    ti = np.array(ti)
+    n = min(len(f), len(ti))
+    ar = np.array(ar)
+    sar = np.array(sar)
+    sar2 = sar ** 2
+    ti = ti * 60  # in seconds
+    sti = [90 for i in range(n)]
+    pi = math.pi
+    pi = 3.141592654
+
+    # sf = sqrt(b ** 2 * siga ** 2 + a ** 2 * sigb ** 2) / (a + b) ** 2
+    # sf = [math.sqrt(sar[i + 1:].sum() ** 2 * (sar[:i + 1] ** 2).sum() + ar[:i + 1].sum() ** 2 * (sar[i + 1:] ** 2).sum()) / ar.sum() ** 2 for i in range(len(ar) - 1)]
+    # sf.append(0)
+
+    f = np.where(f >= 1, 0.9999999999999999, f)
+
+    model = geometric_model(geo='cube')
+    dtr2 = [model(bp=2)[1](fi) for fi in f]
+    dtr2_1 = [model(bp=0)[1](fi) for fi in f]
+    dtr2_2 = [model(bp=2)[1](fi) for fi in f]
+    dtr2_1.insert(0, 0); dtr2_2.insert(0, 0)
+    # dr2 = [(dtr2[i] - (dtr2[i - 1] if i > 0 else 0)) / ti[i] for i in range(len(dtr2))]
+    dr2 = [((dtr2_1[i+1] - dtr2_1[i]) / ti[i]) if f[i] > 0.5 else ((dtr2_2[i+1] - dtr2_2[i]) / ti[i]) for i in range(len(f))]
+
+    # imp = 2
+    # # imp = 1
+    # dtr2 = [pi * (fi / 4) ** 2 if fi <= 0.5 else math.log((1 - fi) * pi ** 2 / 8) / (- pi ** 2) for fi in f]
+    # dr2 = [(dtr2[i] - (dtr2[i - 1] if i > 0 else 0)) / ti[i] * imp ** 2 for i in range(len(dtr2))]
+    # xlogd = [np.log10(i) for i in dr2]
+
+    sar_lt = np.zeros(n)  # 偏导数
+    sar_eq = np.zeros(n)  # 偏导数
+    sar_gt = np.zeros(n)  # 偏导数
+    st = np.zeros(n)  # 偏导数
+    sdr2 = np.zeros(n)
+    for i in range(n):
+        if i == 0:
+            if f[i] <= 2:
+                sar_lt[i] = 0
+                sar_eq[i] = 0
+                sar_gt[i] = 0
+            else:
+                sar_lt[i] = 0
+                sar_eq[i] = (pi / (6 * ti[i]) * (f[i] - 1) ** (1 / 3) * (f[i] - 1) ** (- 2 / 3)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+                sar_gt[i] = (pi / (6 * ti[i]) * (f[i] - 1) ** (1 / 3) * (f[i] - 1) ** (- 2 / 3)) * ((0 - ar[i] - sum(ar[:i])) / sum(ar) ** 2)
+        else:
+            if f[i] <= 2:
+                sar_lt[i] = 0
+                sar_eq[i] = 0
+                sar_gt[i] = 0
+            else:
+                sar_lt[i] = (pi / (6 * ti[i]) * (f[i] - 1) ** (1 / 3) * (f[i] - 1) ** (- 2 / 3)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - (pi / (6 * ti[i]) * (f[i-1] - 1) ** (1 / 3) * (f[i-1] - 1) ** (- 2 / 3)) * ((sum(ar) - ar[i-1] - sum(ar[:i-1])) / sum(ar) ** 2)
+                sar_eq[i] = (pi / (6 * ti[i]) * (f[i] - 1) ** (1 / 3) * (f[i] - 1) ** (- 2 / 3)) * ((sum(ar) - ar[i] - sum(ar[:i])) / sum(ar) ** 2) - (pi / (6 * ti[i]) * (f[i-1] - 1) ** (1 / 3) * (f[i-1] - 1) ** (- 2 / 3)) * ((0 - 0 - sum(ar[:i-1])) / sum(ar) ** 2)
+                sar_gt[i] = (pi / (6 * ti[i]) * (f[i] - 1) ** (1 / 3) * (f[i] - 1) ** (- 2 / 3)) * ((0 - 0 - sum(ar[:i])) / sum(ar) ** 2) - (pi / (6 * ti[i]) * (f[i-1] - 1) ** (1 / 3) * (f[i-1] - 1) ** (- 2 / 3)) * ((0 - 0 - sum(ar[:i-1])) / sum(ar) ** 2)
+                if i == n - 1:
+                    sar_lt[i] = 0
+                    sar_eq[i] = 0
+                    sar_gt[i] = 0
+        st[i] = - dr2[i] / ti[i]
+        sdr2[i] = math.sqrt(sar_lt[i] ** 2 * sum(sar2[:i]) + sar_eq[i] ** 2 * sar2[i] + sar_gt[i] ** 2 * sum(sar2[i+1:]) + st[i] ** 2 * sti[i] ** 2)
+
+    # wt = np.abs(sdr2 / dr2)
+    # wt = errcal(f, ti, ar, sar)
+
+    logdr2 = np.log(dr2) if ln else np.log10(dr2)
+    #ee = 1 / np.log(10)
+    ee = 0.4342944819
+    wt = np.abs(sdr2 / dr2) if ln else np.abs(sdr2 / dr2) * ee
+    #
+    # print(f"{wt = }")
+    # wt = errcal(f, ti, ar, sar)
+    # print(f"{wt = }")
+
+
+    return dr2, logdr2, wt
+
+
 def dr2_thern(f, ti, ar, sar, ln=True):
     """
 
@@ -4716,11 +4956,16 @@ def dr2_thern(f, ti, ar, sar, ln=True):
     wt = np.abs(sdr2 / dr2) if ln else np.abs(sdr2 / dr2) * ee
 
     # dr2, xlogd, wt = dr2_sphere(f, ti, ar, sar, ln, bp=0.85)
-    r2 = 0.01 ** 2
+    r2 = (100 * 0.0001) ** 2  # 100µm to cm
     d = dr2 * r2
     logd = np.log(d)
+    logdr2 = np.log(dr2)
+
+    print(dr2)
+    print(d)
 
     return d, logd, wt
+    # return dr2, logdr2, wt
 
 
 def dr2_yang(f, ti, ar, sar, ln=True):
@@ -4839,6 +5084,10 @@ def geometric_model(geo: str = "sphere"):
         return sphere
     if geo.lower()[:3] == 'plane'[:3]:
         return plane
+    if geo.lower()[:3] == 'cylinder'[:3]:
+        return cylinder
+    if geo.lower()[:3] == 'cube'[:3]:
+        return cube
 
 
 def sphere(bp=0.85):
@@ -4900,3 +5149,63 @@ def plane(bp=0.6):
 
     return func, inv_func
 
+
+def cylinder(bp=0.6):
+    """
+    Parameters
+    ----------
+    bp: float, breakpoint
+
+    Returns
+    -------
+
+    """
+    pi = math.pi
+    pi = 3.141592654
+
+    def func(dtr2):
+        f = 1 - (9 / 13) * math.exp(- 5.78 * dtr2)
+        f2 = (4 / pi ** 1.5) * dtr2 ** 0.5 - dtr2
+        return f if bp <= f <= 1 else f2 if 0 <= f2 else np.nan
+
+    def inv_func(f):
+        if 0 <= f < bp:
+            dtr2 = (1 - math.sqrt(1 - pi * f / 4)) * 8 / pi - f
+        elif f < 1:
+            dtr2 = math.log((1 - f) * 13 / 9) / (- 5.78)
+        else:
+            dtr2 = np.nan
+        return dtr2
+
+    return func, inv_func
+
+
+def cube(bp=2):
+    """
+    Parameters
+    ----------
+    bp: float, breakpoint
+
+    Returns
+    -------
+
+    """
+    pi = math.pi
+    pi = 3.141592654
+
+    def func(dtr2):
+        f = np.nan
+        f2 = 6 * (dtr2 / pi) ** 0.5 - 12 * (dtr2 / pi) + 8 * (dtr2 / pi) ** 1.5  # 0 < f <= 0.97
+        return f if bp <= f <= 1 else f2 if 0 <= f2 else np.nan
+
+    def inv_func(f):
+        if 0 <= f < bp:
+            dtr2 = (pi * ((f - 1) ** (1 / 3) + 1) ** 2) / 4
+        elif f < 1:
+            dtr2 = np.nan
+        else:
+            dtr2 = np.nan
+        return dtr2
+
+    return func, inv_func
+