bindtools 0.1.2__tar.gz → 0.2.1__tar.gz

{bindtools-0.1.2 → bindtools-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindtools
-Version: 0.1.2
+Version: 0.2.1
 Keywords: chemistry,analytical chemistry,binding constants,supramolecular
 Author: Martin Peeks
 Author-email: Martin Peeks <martinp23@googlemail.com>, m.peeks@unsw.edu.au
@@ -14,12 +14,12 @@ Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Dist: arviz==0.21.0
 Requires-Dist: corner==2.2.3
 Requires-Dist: emcee==3.1.6
-Requires-Dist: h5py==3.13.0
+Requires-Dist: h5py>=3.14.0
 Requires-Dist: lmfit==1.3.3
 Requires-Dist: matplotlib==3.10.7
 Requires-Dist: numba>=0.65.1
 Requires-Dist: numpy>=2.3.4
-Requires-Dist: openpyxl==3.1.2
+Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.3.3
 Requires-Dist: scipy==1.16.3
 Requires-Dist: tqdm==4.66.3

{bindtools-0.1.2 → bindtools-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindtools"
-version = "0.1.2"
+version = "0.2.1"
 readme = "README.md"
 classifiers = [
   # How mature is this project? Common values are
@@ -30,12 +30,12 @@ dependencies = [
     "arviz==0.21.0",
     "corner==2.2.3",
     "emcee==3.1.6",
-    "h5py==3.13.0",
+    "h5py>=3.14.0",
     "lmfit==1.3.3",
     "matplotlib==3.10.7",
     "numba>=0.65.1",
     "numpy>=2.3.4",
-    "openpyxl==3.1.2",
+    "openpyxl>=3.1.5",
     "pandas>=2.3.3",
     "scipy==1.16.3",
     "tqdm==4.66.3",

{bindtools-0.1.2 → bindtools-0.2.1}/src/bindtools/binding.py

@@ -97,9 +97,9 @@ def getConcsScipy(eqMat, initComponentConc, logK, alg="L-BFGS-B"):
     eqMat = eqMat.astype("float64")
     K = 10.0**logK
     guessCompConc = np.zeros(len(initComponentConc)) + np.mean(initComponentConc)
-    guessLogCompConc = np.log(guessCompConc)
+    guessLogCompConc = np.log10(guessCompConc)
 
-    bds = [(None, np.log(np.max(initComponentConc))) for _ in range(len(guessLogCompConc))]
+    bds = [(None, np.log10(np.max(initComponentConc))) for _ in range(len(guessLogCompConc))]
     # jac=True says that specObj returns float,arr(n) where arr(n) is the Jacobian
     res = sp.optimize.minimize(
         specObj,
@@ -112,7 +112,7 @@ def getConcsScipy(eqMat, initComponentConc, logK, alg="L-BFGS-B"):
         options={"gtol": 1e-20},
     )
 
-    compTotCalc, specConc = specCalc(np.exp(res.x), len(K), eqMat, K)
+    compTotCalc, specConc = specCalc(10**(res.x), len(K), eqMat, K)
     return specConc
 
 
@@ -150,7 +150,7 @@ def _specJac(ncomp, eqMat, speciesConc):  # this function calculates the Jacobia
 
 
 def specObj(logConc, initComponentConc, eqMat, K):
-    conc = np.exp(logConc)
+    conc = 10**(logConc)
     nspecies = len(K)
     compTotCalc, specConc = specCalc(conc, nspecies, eqMat, K)
 
@@ -228,107 +228,76 @@ def _analytical_obs_param_token(col_name: str) -> str:
     return token
 
 
-def _best_real_root(coeffs: np.ndarray, lower: float, upper: float, score_fn) -> float:
-    nz = np.where(np.abs(coeffs) > 1e-18)[0]
-    if len(nz) == 0:
-        return float(lower)
-
-    trimmed = coeffs[nz[0] :]
-    roots = np.roots(trimmed)
-    real_roots = [float(r.real) for r in roots if abs(r.imag) < 1e-10]
-    if not real_roots:
-        return float(lower)
-
-    bounded = [r for r in real_roots if lower - 1e-12 <= r <= upper + 1e-12]
-    candidates = bounded if bounded else real_roots
-    best = min(candidates, key=score_fn)
-    return float(np.clip(best, lower, upper))
-
-
-def _solve_row_11(h_tot: float, g_tot: float, beta11: float) -> tuple[float, float, float]:
-    if beta11 <= 0:
-        raise ValueError("Binding constant (in natural units) cannot be negative")
-    if h_tot < 0 or g_tot < 0:
-        raise ValueError("Total concentrations must be non-negative")
-    if h_tot == 0 or g_tot == 0:
-        return (
-            max(h_tot, 0.0),
-            max(g_tot, 0.0),
-            0.0,
-        )  # if either total concentration is zero, then there can be no complex
-
-    first_term = h_tot + g_tot + 1.0 / max(beta11, 1e-300)
-    hg = 0.5 * (first_term - math.sqrt(max(first_term**2 - 4.0 * h_tot * g_tot, 0.0)))
-    hg = float(
-        np.clip(hg, 0.0, min(h_tot, g_tot))
-    )  # [HG] cannot be negative or greater than either total concentration
-    return h_tot - hg, g_tot - hg, hg
-
-
-def _solve_row_12(h_tot: float, g_tot: float, beta11: float, beta12: float) -> tuple[float, float, float, float]:
-    if h_tot <= 0 or g_tot <= 0:
-        return max(h_tot, 0.0), max(g_tot, 0.0), 0.0, 0.0
-
-    coeffs = np.array(
-        [
-            beta12,
-            beta11 + 2.0 * h_tot * beta12 - g_tot * beta12,
-            1.0 + h_tot * beta11 - g_tot * beta11,
-            -g_tot,
-        ],
-        dtype=float,
-    )
 
-    def score_fn(g_free: float) -> float:
-        d = 1.0 + beta11 * g_free + beta12 * (g_free**2)
-        if d <= 0:
-            return np.inf
-        h_free = h_tot / d
-        hg = beta11 * h_free * g_free
-        hg2 = beta12 * h_free * (g_free**2)
-        r1 = abs(h_tot - (h_free + hg + hg2))
-        r2 = abs(g_tot - (g_free + hg + 2.0 * hg2))
-        return r1 + r2
-
-    g_free = _best_real_root(coeffs, 0.0, max(g_tot, 0.0), score_fn)
-    d = max(1.0 + beta11 * g_free + beta12 * (g_free**2), 1e-300)
-    h_free = h_tot / d
-    hg = beta11 * h_free * g_free
-    hg2 = beta12 * h_free * (g_free**2)
-    return max(h_free, 0.0), max(g_free, 0.0), max(hg, 0.0), max(hg2, 0.0)
-
-
-def _solve_row_21(h_tot: float, g_tot: float, beta11: float, beta21: float) -> tuple[float, float, float, float]:
-    if h_tot <= 0 or g_tot <= 0:
-        return max(h_tot, 0.0), max(g_tot, 0.0), 0.0, 0.0
-
-    coeffs = np.array(
-        [
-            beta21,
-            beta11 + 2.0 * g_tot * beta21 - h_tot * beta21,
-            1.0 + g_tot * beta11 - h_tot * beta11,
-            -h_tot,
-        ],
-        dtype=float,
-    )
+def _solve_cubic_vectorized(a: np.ndarray, b: np.ndarray, c: np.ndarray, d: np.ndarray, lower: np.ndarray, upper: np.ndarray, score_fn_list) -> np.ndarray:
+    A = b / a
+    B = c / a
+    C = d / a
+
+    p = B - A**2 / 3.0
+    q = C - A * B / 3.0 + 2.0 * A**3 / 27.0
+
+    D = q**2 / 4.0 + p**3 / 27.0
+
+    N = len(a)
+    candidates = np.zeros((3, N), dtype=float)
+
+    mask_single = D > 0
+    mask_three = ~mask_single
+
+    # Solve single root cases (D > 0)
+    if np.any(mask_single):
+        D_s = D[mask_single]
+        q_s = q[mask_single]
+        A_s = A[mask_single]
+
+        sqrt_D = np.sqrt(D_s)
+        val1 = -q_s / 2.0 + sqrt_D
+        val2 = -q_s / 2.0 - sqrt_D
+
+        u = np.sign(val1) * np.abs(val1)**(1.0/3.0)
+        v = np.sign(val2) * np.abs(val2)**(1.0/3.0)
+
+        root_s = u + v - A_s / 3.0
+        candidates[0, mask_single] = root_s
+        candidates[1, mask_single] = root_s
+        candidates[2, mask_single] = root_s
 
-    def score_fn(h_free: float) -> float:
-        d = 1.0 + beta11 * h_free + beta21 * (h_free**2)
-        if d <= 0:
-            return np.inf
-        g_free = g_tot / d
-        hg = beta11 * h_free * g_free
-        h2g = beta21 * (h_free**2) * g_free
-        r1 = abs(h_tot - (h_free + hg + 2.0 * h2g))
-        r2 = abs(g_tot - (g_free + hg + h2g))
-        return r1 + r2
-
-    h_free = _best_real_root(coeffs, 0.0, max(h_tot, 0.0), score_fn)
-    d = max(1.0 + beta11 * h_free + beta21 * (h_free**2), 1e-300)
-    g_free = g_tot / d
-    hg = beta11 * h_free * g_free
-    h2g = beta21 * (h_free**2) * g_free
-    return max(h_free, 0.0), max(g_free, 0.0), max(hg, 0.0), max(h2g, 0.0)
+    # Solve three root cases (D <= 0)
+    if np.any(mask_three):
+        p_t = p[mask_three]
+        q_t = q[mask_three]
+        A_t = A[mask_three]
+
+        valid = -p_t > 1e-12
+        phi = np.zeros_like(p_t)
+        r = np.zeros_like(p_t)
+        if np.any(valid):
+            p_v = p_t[valid]
+            q_v = q_t[valid]
+            cos_phi = (3.0 * q_v) / (2.0 * p_v * np.sqrt(-p_v / 3.0))
+            cos_phi = np.clip(cos_phi, -1.0, 1.0)
+            phi[valid] = np.arccos(cos_phi)
+            r[valid] = 2.0 * np.sqrt(-p_v / 3.0)
+
+        y0 = r * np.cos(phi / 3.0)
+        y1 = r * np.cos(phi / 3.0 + 2.0 * np.pi / 3.0)
+        y2 = r * np.cos(phi / 3.0 + 4.0 * np.pi / 3.0)
+
+        candidates[0, mask_three] = y0 - A_t / 3.0
+        candidates[1, mask_three] = y1 - A_t / 3.0
+        candidates[2, mask_three] = y2 - A_t / 3.0
+
+    # Evaluate residuals using the vectorized score function
+    residuals = score_fn_list(candidates)
+
+    # Penalize out of bounds candidates
+    out_of_bounds = (candidates < lower - 1e-12) | (candidates > upper + 1e-12)
+    residuals[out_of_bounds] += 1e10
+
+    best_idx = np.argmin(residuals, axis=0)
+    best_root = candidates[best_idx, np.arange(N)]
+    return np.clip(best_root, lower, upper)
 
 
 def calc_analytical_speciation(
@@ -340,46 +309,128 @@ def calc_analytical_speciation(
     complex_indices: list[int],
 ) -> tuple[np.ndarray, bool]:
 
+    if n_comp != 2:
+        raise ValueError("Analytical fast-exchange solver requires exactly 2 components.")
+
     n_rows = int(np.shape(comp_concs)[0])
     n_species = int(np.shape(eq_mat)[1])
     spec_calc = np.zeros((n_rows, n_species), dtype=float)
     error = False
 
-    if n_comp != 2:
-        raise ValueError("Analytical fast-exchange solver requires exactly 2 components.")
+    h_tot = np.maximum(comp_concs[:, 0], 0.0)
+    g_tot = np.maximum(comp_concs[:, 1], 0.0)
+    zero_mask = (h_tot <= 0.0) | (g_tot <= 0.0)
 
     beta11 = 10.0 ** float(binding_params[complex_indices[0]])
-    beta2 = None
-    if topology in ("1:2", "2:1"):
-        beta2 = 10.0 ** float(binding_params[complex_indices[1]])
 
-    for ii, row in enumerate(comp_concs):
-        h_tot = float(max(row[0], 0.0))
-        g_tot = float(max(row[1], 0.0))
-        try:
-            if topology == "1:1":
-                h_free, g_free, hg = _solve_row_11(h_tot, g_tot, beta11)
-                spec_calc[ii, 0] = h_free
-                spec_calc[ii, 1] = g_free
-                spec_calc[ii, complex_indices[0]] = hg
-            elif topology == "1:2":
-                h_free, g_free, hg, hg2 = _solve_row_12(h_tot, g_tot, beta11, float(beta2))
-                spec_calc[ii, 0] = h_free
-                spec_calc[ii, 1] = g_free
-                spec_calc[ii, complex_indices[0]] = hg
-                spec_calc[ii, complex_indices[1]] = hg2
-            elif topology == "2:1":
-                h_free, g_free, hg, h2g = _solve_row_21(h_tot, g_tot, beta11, float(beta2))
-                spec_calc[ii, 0] = h_free
-                spec_calc[ii, 1] = g_free
-                spec_calc[ii, complex_indices[0]] = hg
-                spec_calc[ii, complex_indices[1]] = h2g
+    try:
+        if topology == "1:1":
+            if beta11 <= 0:
+                spec_calc[:, 0] = h_tot
+                spec_calc[:, 1] = g_tot
             else:
-                raise ValueError(f"Unsupported analytical topology: {topology}")
-        except Exception:
-            error = True
+                first_term = h_tot + g_tot + 1.0 / max(beta11, 1e-300)
+                sqrt_val = np.sqrt(np.maximum(first_term**2 - 4.0 * h_tot * g_tot, 0.0))
+                hg = 0.5 * (first_term - sqrt_val)
+                hg = np.clip(hg, 0.0, np.minimum(h_tot, g_tot))
+                hg[zero_mask] = 0.0
+                
+                spec_calc[:, 0] = np.maximum(h_tot - hg, 0.0)
+                spec_calc[:, 1] = np.maximum(g_tot - hg, 0.0)
+                spec_calc[:, complex_indices[0]] = hg
+
+        elif topology == "1:2":
+            beta12 = 10.0 ** float(binding_params[complex_indices[1]])
+            
+            # Setup coefficients for cubic equation a*g^3 + b*g^2 + c*g + d = 0
+            a = np.full(n_rows, beta12, dtype=float)
+            b = beta11 + 2.0 * h_tot * beta12 - g_tot * beta12
+            c = 1.0 + h_tot * beta11 - g_tot * beta11
+            d = -g_tot
+            
+            def score_12(g_free_candidates):
+                h_t = h_tot[np.newaxis, :]
+                g_t = g_tot[np.newaxis, :]
+                denom = np.maximum(1.0 + beta11 * g_free_candidates + beta12 * (g_free_candidates**2), 1e-300)
+                h_f = h_t / denom
+                hg = beta11 * h_f * g_free_candidates
+                hg2 = beta12 * h_f * (g_free_candidates**2)
+                r1 = np.abs(h_t - (h_f + hg + hg2))
+                r2 = np.abs(g_t - (g_free_candidates + hg + 2.0 * hg2))
+                return r1 + r2
+
+            g_free = _solve_cubic_vectorized(a, b, c, d, np.zeros(n_rows), g_tot, score_12)
+            denom = np.maximum(1.0 + beta11 * g_free + beta12 * (g_free**2), 1e-300)
+            h_free = h_tot / denom
+            hg = beta11 * h_free * g_free
+            hg2 = beta12 * h_free * (g_free**2)
+            
+            # Apply zero/negative overrides
+            h_free = np.maximum(h_free, 0.0)
+            g_free = np.maximum(g_free, 0.0)
+            hg = np.maximum(hg, 0.0)
+            hg2 = np.maximum(hg2, 0.0)
+            
+            h_free[zero_mask] = h_tot[zero_mask]
+            g_free[zero_mask] = g_tot[zero_mask]
+            hg[zero_mask] = 0.0
+            hg2[zero_mask] = 0.0
+            
+            spec_calc[:, 0] = h_free
+            spec_calc[:, 1] = g_free
+            spec_calc[:, complex_indices[0]] = hg
+            spec_calc[:, complex_indices[1]] = hg2
+
+        elif topology == "2:1":
+            beta21 = 10.0 ** float(binding_params[complex_indices[1]])
+            
+            # Setup coefficients for cubic equation a*h^3 + b*h^2 + c*h + d = 0
+            a = np.full(n_rows, beta21, dtype=float)
+            b = beta11 + 2.0 * g_tot * beta21 - h_tot * beta21
+            c = 1.0 + g_tot * beta11 - h_tot * beta11
+            d = -h_tot
+            
+            def score_21(h_free_candidates):
+                h_t = h_tot[np.newaxis, :]
+                g_t = g_tot[np.newaxis, :]
+                denom = np.maximum(1.0 + beta11 * h_free_candidates + beta21 * (h_free_candidates**2), 1e-300)
+                g_f = g_t / denom
+                hg = beta11 * h_free_candidates * g_f
+                h2g = beta21 * (h_free_candidates**2) * g_f
+                r1 = np.abs(h_t - (h_free_candidates + hg + 2.0 * h2g))
+                r2 = np.abs(g_t - (g_f + hg + h2g))
+                return r1 + r2
+
+            h_free = _solve_cubic_vectorized(a, b, c, d, np.zeros(n_rows), h_tot, score_21)
+            denom = np.maximum(1.0 + beta11 * h_free + beta21 * (h_free**2), 1e-300)
+            g_free = g_tot / denom
+            hg = beta11 * h_free * g_free
+            h2g = beta21 * (h_free**2) * g_free
+            
+            # Apply zero/negative overrides
+            h_free = np.maximum(h_free, 0.0)
+            g_free = np.maximum(g_free, 0.0)
+            hg = np.maximum(hg, 0.0)
+            h2g = np.maximum(h2g, 0.0)
+            
+            h_free[zero_mask] = h_tot[zero_mask]
+            g_free[zero_mask] = g_tot[zero_mask]
+            hg[zero_mask] = 0.0
+            h2g[zero_mask] = 0.0
+            
+            spec_calc[:, 0] = h_free
+            spec_calc[:, 1] = g_free
+            spec_calc[:, complex_indices[0]] = hg
+            spec_calc[:, complex_indices[1]] = h2g
+
+        else:
+            raise ValueError(f"Unsupported analytical topology: {topology}")
+    except Exception:
+        error = True
+        # Fallback to numerical solver row-by-row
+        for ii in range(n_rows):
             try:
-                spec_calc[ii, :] = getConcs(eq_mat, np.array([h_tot, g_tot]), binding_params)
+                spec_calc[ii, :] = getConcs(eq_mat, comp_concs[ii], binding_params)
             except Exception:
                 spec_calc[ii, :] = 0.0
 
@@ -567,15 +618,29 @@ def fitfun(params, fcn_opts):  # ,eqMat,specConcs,startShifts=None,sigma=1,ret='
 
     bindingParams = np.array([*parvals][: fcn_opts["nK"]], dtype=np.float64)
     error = False
-    specCalc = []
-    for row in fcn_opts["compConcs"]:
-        try:
-            yEq = getConcs(fcn_opts["eqMat"], row, bindingParams)
-        except EquilibriumError as e:
-            yEq = e.val
-            error = True
-        specCalc.append(yEq)  # yEq[4:])
-    specCalc = np.array(specCalc)
+
+    analytical_topology = fcn_opts.get("analytical_topology")
+    if analytical_topology in ("1:1", "1:2", "2:1"):
+        comp_concs = np.array(fcn_opts["compConcs"], dtype=float)
+        complex_indices = [int(x) for x in fcn_opts.get("analytical_complex_indices", [])]
+        specCalc, error = calc_analytical_speciation(
+            comp_concs=comp_concs,
+            eq_mat=np.array(fcn_opts["eqMat"], dtype=float),
+            binding_params=bindingParams,
+            topology=str(analytical_topology),
+            n_comp=int(comp_concs.shape[1]),
+            complex_indices=complex_indices,
+        )
+    else:
+        specCalc = []
+        for row in fcn_opts["compConcs"]:
+            try:
+                yEq = getConcs(fcn_opts["eqMat"], row, bindingParams)
+            except EquilibriumError as e:
+                yEq = e.val
+                error = True
+            specCalc.append(yEq)  # yEq[4:])
+        specCalc = np.array(specCalc)
     # except EquilibriumError as e:
     #     if fcn_opts['ret'] == 'residual':
     #         return 1000
@@ -782,6 +847,36 @@ def concToObservable(specConcs, specToInteg, specToDd, shiftParams, paramNames,
 #     return sum((specConcs.flatten() - res)**2)
 
 
+def _infer_simple_fast_exchange_topology(eq_mat: np.ndarray, n_comp: int) -> Optional[tuple[str, list[int]]]:
+    if not isinstance(eq_mat, np.ndarray) or eq_mat.ndim != 2:
+        return None
+    if n_comp != 2 or eq_mat.shape[0] != 2 or eq_mat.shape[1] <= n_comp:
+        return None
+
+    bound_indices = list(range(n_comp, eq_mat.shape[1]))
+    sig_to_idx = {}
+    for idx in bound_indices:
+        a = eq_mat[0, idx]
+        b = eq_mat[1, idx]
+        if not np.isfinite(a) or not np.isfinite(b):
+            return None
+        if not np.isclose(a, round(a)) or not np.isclose(b, round(b)):
+            return None
+        sig = (int(round(a)), int(round(b)))
+        if sig in sig_to_idx:
+            return None
+        sig_to_idx[sig] = idx
+
+    sigs = set(sig_to_idx.keys())
+    if len(bound_indices) == 1 and sigs == {(1, 1)}:
+        return "1:1", [sig_to_idx[(1, 1)]]
+    if len(bound_indices) == 2 and sigs == {(1, 1), (1, 2)}:
+        return "1:2", [sig_to_idx[(1, 1)], sig_to_idx[(1, 2)]]
+    if len(bound_indices) == 2 and sigs == {(1, 1), (2, 1)}:
+        return "2:1", [sig_to_idx[(1, 1)], sig_to_idx[(2, 1)]]
+    return None
+
+
 class bindingModel:
     def __init__(
         self,
@@ -901,7 +996,108 @@ class bindingModel:
     def setColumnToSpeciesMapping(self, colToSpec):
         self.colToSpec = colToSpec
 
-    def prepModel(self):
+    def prepModel(self, force_numerical=False):
+        if force_numerical:
+            self.analytical_fast_exchange = False
+            self.analytical_topology = None
+            self.analytical_obs_columns = []
+            self.analytical_obs_components = []
+            self.analytical_complex_indices = []
+            self.analytical_obs_param_map = []
+            self.analytical_linear_obs_columns = []
+            self.analytical_linear_obs_param_map = []
+        else:
+            if not self.analytical_topology:
+                topology_res = _infer_simple_fast_exchange_topology(self.eqMat, len(self.compNames))
+                if topology_res is not None:
+                    self.analytical_topology, self.analytical_complex_indices = topology_res
+
+            if self.analytical_topology in ("1:1", "1:2", "2:1") and not self.analytical_fast_exchange:
+                # 1. Check slow exchange mapping (specToInteg / colToSpec)
+                has_slow_exchange = False
+                if self.colToSpec is not None and self.colToSpec.size > 0:
+                    try:
+                        flat_vals = []
+                        for x in self.colToSpec.flat:
+                            try:
+                                val = float(x)
+                            except (TypeError, ValueError):
+                                val = 0.0
+                            flat_vals.append(val)
+                        flat_arr = np.array(flat_vals)
+                        if np.any(~np.isclose(flat_arr, 0.0)):
+                            has_slow_exchange = True
+                    except Exception:
+                        pass
+
+                # 2. Check types of columns (NMR vs Linear vs Mixed)
+                n_integ = self.colToSpec.shape[1] if (self.colToSpec is not None and self.colToSpec.size > 0) else 0
+                n_linear = self.specToLinear.shape[1] if (self.specToLinear is not None and self.specToLinear.size > 0) else 0
+                n_shift = self.specToDd.shape[1] if (self.specToDd is not None and self.specToDd.size > 0) else 0
+
+                obs_list = self.obsList if self.obsList is not None else []
+                if n_shift == 0:
+                    n_shift = max(0, len(obs_list) - n_integ - n_linear)
+
+                if len(obs_list) < n_integ + n_linear + n_shift:
+                    obs_list = list(obs_list) + [f"obs_{i}" for i in range(len(obs_list), n_integ + n_linear + n_shift)]
+
+                linear_cols = obs_list[n_integ:n_integ + n_linear]
+                shift_cols = obs_list[n_integ + n_linear:n_integ + n_linear + n_shift]
+
+
+                if not has_slow_exchange and not (n_shift > 0 and n_linear > 0) and (n_shift > 0 or n_linear > 0):
+                    self.analytical_fast_exchange = True
+
+                    if n_linear > 0:
+                        self.analytical_linear_obs_columns = linear_cols
+                        linear_obs_param_map = []
+                        for obs_idx in range(n_linear):
+                            pnames = []
+                            for species_idx in range(self.specToLinear.shape[0]):
+                                cell = self.specToLinear[species_idx, obs_idx]
+                                if isinstance(cell, lmfit.Parameter):
+                                    pnames.append(cell.name)
+                                else:
+                                    pnames.append(None)
+                            linear_obs_param_map.append(pnames)
+                        self.analytical_linear_obs_param_map = linear_obs_param_map
+                        self.analytical_obs_columns = []
+                        self.analytical_obs_components = []
+                    else:
+                        self.analytical_obs_columns = shift_cols
+
+                        def is_nonzero_mapping(cell):
+                            if cell is None:
+                                return False
+                            if isinstance(cell, (int, float)):
+                                return not np.isclose(cell, 0.0)
+                            return True
+
+                        obs_components = []
+                        for obs_idx in range(n_shift):
+                            has_comp0 = False
+                            has_comp1 = False
+                            if self.specToDd is not None and self.specToDd.shape[0] > 1:
+                                has_comp0 = is_nonzero_mapping(self.specToDd[0, obs_idx])
+                                has_comp1 = is_nonzero_mapping(self.specToDd[1, obs_idx])
+
+                            if has_comp0 and not has_comp1:
+                                obs_components.append(0)
+                            elif has_comp1 and not has_comp0:
+                                obs_components.append(1)
+                            else:
+                                col_name = shift_cols[obs_idx] if obs_idx < len(shift_cols) else ""
+                                tokens = [t for t in re.split(r"[^A-Za-z0-9]+", col_name.lower()) if t]
+                                matches = [idx for idx, comp in enumerate(self.compNames) if str(comp).lower() in tokens]
+                                if len(matches) == 1:
+                                    obs_components.append(matches[0])
+                                else:
+                                    obs_components.append(obs_idx % 2)
+                        self.analytical_obs_components = obs_components
+                        self.analytical_linear_obs_columns = []
+                        self.analytical_linear_obs_param_map = []
+
         for paramName in self.compNames:
             self._addParam("log" + paramName, init=0, vary=False)
 
@@ -1387,6 +1583,7 @@ class MCMC:
         self.variance = variance
         self.sampler = None
         self._labels = None
+        self.thin = 1
 
     @property
     def labels(self):
@@ -1405,6 +1602,7 @@ class MCMC:
         return params
 
     def run(self, ret=False, thin=1, samples=None, pool=None, tqdm_kwargs=None):
+        self.thin = thin
         bm = self.model
         bm.colTypes = self.obs
 
@@ -1470,7 +1668,7 @@ class MCMC:
                     )
                 else:
                     self.sampler.pool = active_pool
-                self.sampler.run_mcmc(p0, samples, progress=True, progress_kwargs=tqdm_kwargs)
+                self.sampler.run_mcmc(p0, samples, progress=True, thin_by=thin, progress_kwargs=tqdm_kwargs)
         else:
             if self.sampler is None:
                 self.sampler = emcee.EnsembleSampler(self.walkers, ndim, log_prob, args=[bm.fcn_opts, bounds])
@@ -1559,6 +1757,7 @@ class MCMC:
             else:
                 g.attrs["has_blobs"] = False
             g.attrs["iteration"] = self.sampler.backend.iteration
+            g.attrs["thin"] = getattr(self, "thin", 1)
 
     def load(self, fname):
         if self.sampler is None:
@@ -1574,6 +1773,8 @@ class MCMC:
                 self.sampler.backend.blobs = g["blobs"][:]
             self.sampler.backend.iteration = g.attrs["iteration"]
             self.sampler.backend.log_prob = g["log_prob"][:]
+            if "thin" in g.attrs:
+                self.thin = int(g.attrs["thin"])
             # sampler.backend.random_state = g['random_state'][:]
             self.sampler.backend.initialized = True
             self.sampler._previous_state = self.sampler.get_last_sample()