bindtools 0.1.3__tar.gz → 0.2.2__tar.gz

{bindtools-0.1.3 → bindtools-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindtools
-Version: 0.1.3
+Version: 0.2.2
 Keywords: chemistry,analytical chemistry,binding constants,supramolecular
 Author: Martin Peeks
 Author-email: Martin Peeks <martinp23@googlemail.com>, m.peeks@unsw.edu.au
@@ -19,7 +19,7 @@ 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.3 → bindtools-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindtools"
-version = "0.1.3"
+version = "0.2.2"
 readme = "README.md"
 classifiers = [
   # How mature is this project? Common values are
@@ -35,7 +35,7 @@ dependencies = [
     "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.3 → bindtools-0.2.2}/src/bindtools/binding.py

@@ -218,117 +218,76 @@ def DoNR(eqMat, K, initComponentConc, guessCompConc):
     )
 
 
-def _analytical_obs_param_token(col_name: str) -> str:
-    token = re.sub(r"[^\w]+", "_", str(col_name))
-    token = re.sub(r"_+", "_", token).strip("_")
-    if not token:
-        token = "obs"
-    if not (token[0].isalpha() or token[0] == "_"):
-        token = f"obs_{token}"
-    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,208 +299,134 @@ 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
 
     return spec_calc, error
 
 
-def _analytical_param_value(values: np.ndarray, name_to_idx: dict[str, int], param_name: str) -> float:
-    idx = name_to_idx.get(param_name)
-    if idx is None or idx >= len(values):
-        return 0.0
-    return float(values[idx])
-
-
-def calc_analytical_observables(
-    spec_calc: np.ndarray,
-    comp_concs: np.ndarray,
-    eq_mat: np.ndarray,
-    obs_components: list[int],
-    complex_indices: list[int],
-    shift_param_values: np.ndarray,
-    shift_param_names: list[str],
-    obs_param_map: list[list[str]],
-) -> np.ndarray:
-
-    n_obs = len(obs_components)
-    out = np.zeros((spec_calc.shape[0], n_obs), dtype=float)
-    name_to_idx = {name: i for i, name in enumerate(shift_param_names)}
-
-    for obs_idx in range(n_obs):
-        comp_idx = int(obs_components[obs_idx])
-        denom = comp_concs[:, comp_idx]
-        pnames = obs_param_map[obs_idx]
-        baseline = _analytical_param_value(shift_param_values, name_to_idx, pnames[0])
-        out[:, obs_idx] = baseline
-
-        for cidx, complex_idx in enumerate(complex_indices):
-            if cidx + 1 >= len(pnames):
-                continue
-            amp = _analytical_param_value(shift_param_values, name_to_idx, pnames[cidx + 1])
-            stoich = float(eq_mat[comp_idx, complex_idx])
-            frac = np.zeros_like(denom, dtype=float)
-            np.divide(
-                stoich * spec_calc[:, complex_idx],
-                denom,
-                out=frac,
-                where=np.isfinite(denom) & (np.abs(denom) > 0),
-            )
-            out[:, obs_idx] += amp * frac
-
-    return out
-
-
-def calc_analytical_linear_observables(
-    spec_calc: np.ndarray,
-    linear_param_values: np.ndarray,
-    linear_param_names: list,
-    linear_obs_param_map: list,
-) -> np.ndarray:
-    """Compute concentration-weighted linear observables for the analytical fast-exchange path.
-
-    Used for UV-vis (Beer-Lambert) and fluorescence:  A_i = sum_j eps_{ij} * [species_j].
-
-    Args:
-        spec_calc: species concentrations, shape (n_pts, n_species).
-        linear_param_values: flat array of current non-binding parameter values.
-        linear_param_names: list of param names corresponding to linear_param_values.
-        linear_obs_param_map: list of lists; outer index = observable column, inner index = species.
-            Each inner entry is a param name string or None (dark/silent species).
-
-    Returns:
-        ndarray of shape (n_pts, n_obs).
-    """
-    n_obs = len(linear_obs_param_map)
-    out = np.zeros((spec_calc.shape[0], n_obs), dtype=float)
-    name_to_idx = {name: i for i, name in enumerate(linear_param_names)}
-
-    for obs_idx, pnames in enumerate(linear_obs_param_map):
-        for species_idx, pname in enumerate(pnames):
-            if not pname:
-                continue  # dark / silent species
-            coeff = _analytical_param_value(linear_param_values, name_to_idx, pname)
-            out[:, obs_idx] += coeff * spec_calc[:, species_idx]
-
-    return out
-
-
-def fitfun_analytical_fast_exchange(params, fcn_opts):
-    if isinstance(params, lmfit.parameter.Parameters):
-        parvals = list(params.valuesdict().values())
-    else:
-        parvals = params
-
-    nK = int(fcn_opts["nK"])
-    binding_params = np.array([*parvals][:nK], dtype=np.float64)
-    comp_concs = np.array(fcn_opts["compConcs"], dtype=float)
-    eq_mat = np.array(fcn_opts["eqMat"], dtype=float)
-    topology = str(fcn_opts.get("analytical_topology", ""))
-    complex_indices = [int(x) for x in fcn_opts.get("analytical_complex_indices", [])]
-    obs_components = [int(x) for x in fcn_opts.get("analytical_obs_components", [])]
-    obs_param_map = list(fcn_opts.get("analytical_obs_param_map", []))
-    linear_obs_param_map = list(fcn_opts.get("analytical_linear_obs_param_map", []))
-
-    spec_calc, error = calc_analytical_speciation(
-        comp_concs=comp_concs,
-        eq_mat=eq_mat,
-        binding_params=binding_params,
-        topology=topology,
-        n_comp=int(comp_concs.shape[1]),
-        complex_indices=complex_indices,
-    )
-
-    if fcn_opts["optTarget"] == "concs":
-        if fcn_opts["ret"] == "residual":
-            res = (fcn_opts["exptData"] - spec_calc) / fcn_opts["sigma"]
-            if error and fcn_opts["mcmc"] is True:
-                return np.nan
-            if error:
-                res = res * 10
-            return res
-        if fcn_opts["ret"] == "concs":
-            return spec_calc
-        return -1
-
-    shift_params = np.array([*parvals][nK:], dtype=np.float64)
-    shift_param_names = fcn_opts["paramNames"][nK:]
-
-    # Route to linear (UV-vis / fluorescence) or NMR-shift observable calculation.
-    if linear_obs_param_map:
-        obs_calc = calc_analytical_linear_observables(
-            spec_calc=spec_calc,
-            linear_param_values=shift_params,
-            linear_param_names=shift_param_names,
-            linear_obs_param_map=linear_obs_param_map,
-        )
-    else:
-        obs_calc = calc_analytical_observables(
-            spec_calc=spec_calc,
-            comp_concs=comp_concs,
-            eq_mat=eq_mat,
-            obs_components=obs_components,
-            complex_indices=complex_indices,
-            shift_param_values=shift_params,
-            shift_param_names=shift_param_names,
-            obs_param_map=obs_param_map,
-        )
-
-    if fcn_opts["ret"] == "residual":
-        res = (fcn_opts["exptData"] - obs_calc) / fcn_opts["sigma"]
-        nan_mask = np.isnan(fcn_opts["exptData"])
-        res[nan_mask] = 0
-        if error and fcn_opts["mcmc"] is True:
-            return np.nan
-        if error:
-            res = res * 10
-        if fcn_opts["mcmc"] is True:
-            res = np.nan_to_num(res)
-        return res
-    if fcn_opts["ret"] == "concs":
-        return obs_calc
-    return -1
-
-
 def fitfun(params, fcn_opts):  # ,eqMat,specConcs,startShifts=None,sigma=1,ret='residual'):
 
     # fcn_opts = {'compConcs': compConcs,
@@ -553,12 +438,7 @@ def fitfun(params, fcn_opts):  # ,eqMat,specConcs,startShifts=None,sigma=1,ret='
     #             'sigma': 1,
     #             'ret': 'residual'}
 
-    if fcn_opts.get("analytical_fast_exchange") is True and fcn_opts.get("analytical_topology") in (
-        "1:1",
-        "1:2",
-        "2:1",
-    ):
-        return fitfun_analytical_fast_exchange(params, fcn_opts)
+
 
     if isinstance(params, lmfit.parameter.Parameters):
         parvals = list(params.valuesdict().values())
@@ -676,12 +556,12 @@ def concToDelta(concs, specToDd, shiftParams, paramNames):
     specToDdTrial = specToDdTrial.astype(np.float64)
 
     # normalize concs to mol fractions
-    truthMat = np.array(specToDdTrial, dtype=bool)
+    truthMat = ~np.isnan(specToDdTrial)
     shiftCalc = []
     for cc in concs:
         tt = (truthMat.T * cc).T
         moleFracs = tt / tt.sum(axis=0)
-        sc = (moleFracs * specToDdTrial).sum(axis=0)
+        sc = np.nansum(moleFracs * specToDdTrial, axis=0)
         shiftCalc.append(sc)
 
     return shiftCalc
@@ -796,6 +676,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,
@@ -843,12 +753,7 @@ class bindingModel:
         self.specToLinear: Optional[np.ndarray] = None  # (n_species, n_obs) object array for UV-vis / fluorescence
         self.analytical_fast_exchange: bool = False
         self.analytical_topology: Optional[str] = None
-        self.analytical_obs_columns: list[str] = []
-        self.analytical_obs_components: list[int] = []
         self.analytical_complex_indices: list[int] = []
-        self.analytical_obs_param_map: list[list[str]] = []
-        self.analytical_linear_obs_columns: list[str] = []
-        self.analytical_linear_obs_param_map: list[list] = []  # per-obs list of param names (or None) in species order
 
         self.params = lmfit.Parameters()
         self.mini = None
@@ -915,7 +820,24 @@ 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
+
+
+
         for paramName in self.compNames:
             self._addParam("log" + paramName, init=0, vary=False)
 
@@ -929,22 +851,7 @@ class bindingModel:
                 if isinstance(x, lmfit.Parameter):
                     self._addExistingParam(x)
 
-        if self.analytical_fast_exchange:
-            n_complex = len(self.analytical_complex_indices)
-            if n_complex == 0:
-                n_complex = 1
-            self.analytical_obs_param_map = []
-            for col_name in self.analytical_obs_columns:
-                token = _analytical_obs_param_token(col_name)
-                pname_list = [f"delta0_{token}"]
-                self._addParam(pname_list[0], init=0.0, min=-1000, max=1000, vary=True)
-                for cidx in range(n_complex):
-                    pname = f"deltac{cidx + 1}_{token}"
-                    pname_list.append(pname)
-                    self._addParam(pname, init=0.0, min=-1000, max=1000, vary=True)
-                self.analytical_obs_param_map.append(pname_list)
-            # specToLinear params already registered above; no further action needed.
-            return
+
 
         # add chemical shift fitting params
         if self.specToDd is not None:
@@ -990,11 +897,7 @@ class bindingModel:
             "paramNames": list(self.params.keys()),
             "analytical_fast_exchange": analytical_mode,
             "analytical_topology": self.analytical_topology,
-            "analytical_obs_columns": list(self.analytical_obs_columns),
-            "analytical_obs_components": list(self.analytical_obs_components),
             "analytical_complex_indices": list(self.analytical_complex_indices),
-            "analytical_obs_param_map": [list(x) for x in self.analytical_obs_param_map],
-            "analytical_linear_obs_param_map": [list(x) for x in self.analytical_linear_obs_param_map],
         }
 
         # save settings for later plots
@@ -1046,10 +949,7 @@ class bindingModel:
             "paramNames": list(params.keys()),
             "analytical_fast_exchange": bool(self.analytical_fast_exchange),
             "analytical_topology": self.analytical_topology,
-            "analytical_obs_columns": list(self.analytical_obs_columns),
-            "analytical_obs_components": list(self.analytical_obs_components),
             "analytical_complex_indices": list(self.analytical_complex_indices),
-            "analytical_obs_param_map": [list(x) for x in self.analytical_obs_param_map],
         }
 
         return np.array(fitfun(params, fcn_opts))
@@ -1401,6 +1301,7 @@ class MCMC:
         self.variance = variance
         self.sampler = None
         self._labels = None
+        self.thin = 1
 
     @property
     def labels(self):
@@ -1419,6 +1320,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
 
@@ -1484,7 +1386,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])
@@ -1573,6 +1475,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:
@@ -1588,6 +1491,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()