bindmc 0.1.5__tar.gz → 0.1.7__tar.gz

{bindmc-0.1.5 → bindmc-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindmc
-Version: 0.1.5
+Version: 0.1.7
 Keywords: chemistry,analytical chemistry,binding constants,supramolecular
 Author: Martin Peeks
 Author-email: Martin Peeks <martinp23@googlemail.com>, m.peeks@unsw.edu.au
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Dist: arviz==0.21.0
-Requires-Dist: bindtools>=0.1.3
+Requires-Dist: bindtools>=0.2.2
 Requires-Dist: corner==2.2.3
 Requires-Dist: emcee==3.1.6
 Requires-Dist: h5py>=3.14.0
@@ -22,7 +22,7 @@ Requires-Dist: matplotlib==3.10.7
 Requires-Dist: nicegui[plotly]==3.3.1
 Requires-Dist: numba>=0.65.1
 Requires-Dist: numpy>=2.3.5
-Requires-Dist: openpyxl==3.1.2
+Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.3.3
 Requires-Dist: platformdirs>=3.0.0
 Requires-Dist: pywebview>=5
@@ -53,6 +53,16 @@ Download the latest executable for your platform from the [Releases](https://git
 pip install bindmc
 ```
 
+## Upgrades
+
+### Pre-built Binary
+Re-download from the link above. 
+
+### Pip
+```bash
+pip install --upgrade bindmc
+```
+
 ## Usage
 
 If using the pre-built binary, run the downloaded executable.

{bindmc-0.1.5 → bindmc-0.1.7}/README.md

@@ -15,6 +15,16 @@ Download the latest executable for your platform from the [Releases](https://git
 pip install bindmc
 ```
 
+## Upgrades
+
+### Pre-built Binary
+Re-download from the link above. 
+
+### Pip
+```bash
+pip install --upgrade bindmc
+```
+
 ## Usage
 
 If using the pre-built binary, run the downloaded executable.

{bindmc-0.1.5 → bindmc-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindmc"
-version = "0.1.5"
+version = "0.1.7"
 readme = "README.md"
 keywords = ["chemistry", "analytical chemistry", "binding constants", "supramolecular"]
 classifiers = [
@@ -28,7 +28,7 @@ classifiers = [
 requires-python = ">=3.12"
 dependencies = [
     "arviz==0.21.0",
-    "bindtools>=0.1.3",
+    "bindtools>=0.2.2",
     "corner==2.2.3",
     "emcee==3.1.6",
     "h5py>=3.14.0",
@@ -38,7 +38,7 @@ dependencies = [
     "nicegui[plotly]==3.3.1",
     "numba>=0.65.1",
     "numpy>=2.3.5",
-    "openpyxl==3.1.2",
+    "openpyxl>=3.1.5",
     "pandas>=2.3.3",
     "platformdirs>=3.0.0",
     "pywebview>=5",

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/__main__.py

@@ -2,3 +2,5 @@
 
 if __name__ in {"__main__", "__mp_main__"}:
     import bindmc.main
+    bindmc.main.main()
+

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/main.py

@@ -18,6 +18,11 @@ from nicegui import native, ui, app
 from bindmc.webgui.app import BindMCServer
 import logging
 import nicegui
+import nicegui.binding
+
+# Suppress NiceGUI's data binding warning (which confuses users with chemical binding)
+nicegui.binding.MAX_PROPAGATION_TIME = float("inf")
+
 from packaging.version import InvalidVersion, Version
 from pathlib import Path
 from platformdirs import user_data_dir
@@ -107,7 +112,11 @@ storage_path.mkdir(parents=True, exist_ok=True)
 # Redirect native window persistence data away from default paths
 app.native.start_args["storage_path"] = str(storage_path)
 
+def main() -> None:
+    ui.run(title="BindMC", reload=reload, native=native_mode, port=native.find_open_port(), storage_secret="bindmc_secret", reconnect_timeout=300)
+
 if __name__ in {"__main__", "__mp_main__"}:
-    ui.run(title="BindMC", reload=reload, native=native_mode, port=native.find_open_port(), storage_secret="bindmc_secret")
+    main()
+
 
 

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/classes/ExptData.py

@@ -443,7 +443,7 @@ class ExptData:
                     species_key = species_names[j]
                     parameter_matrix[i, j] = _get_parameter_for_species(species_key, delta_col)
                 else:
-                    parameter_matrix[i, j] = 0.0
+                    parameter_matrix[i, j] = None
 
         self.delta_to_spec = parameter_matrix
         return parameter_matrix

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/classes/FitResult.py

@@ -30,8 +30,6 @@ class FitResult:
     bd_model: Optional[bd.bindingModel] = None
     analytical_fast_exchange: bool = False
     analytical_topology: Optional[str] = None
-    analytical_obs_columns: list[str] = field(default_factory=list)
-    analytical_obs_components: list[int] = field(default_factory=list)
     analytical_complex_indices: list[int] = field(default_factory=list)
 
     init_model: InitVar[Optional[Model]] = None  # The model used for the fit, if any
@@ -150,8 +148,6 @@ class FitResult:
             "success": self.success,
             "analytical_fast_exchange": 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),
             "fit_speciation": (
                 self.fit_speciation.to_dict(orient="list") if isinstance(self.fit_speciation, pd.DataFrame) else {}

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/classes/MCMCSim.py

@@ -25,6 +25,7 @@ class MCMCSim:
 
     burn: int = 100
     thin: int = 1
+    max_retained_points: int = 1000
     seed: Optional[int] = None
     chains: np.ndarray = field(default_factory=lambda: np.array([]))  # Array to hold the MCMC chains
     priors: list[dict[str, Any]] = field(default_factory=list)
@@ -198,11 +199,17 @@ class MCMCSim:
                     logger.info("MCMC run cancelled.")
                     return self.mc
                 chunk_size = self.chunk_size_val.value
-                samples = min(chunk_size, self.nsteps_target - self.nsteps_done)
+                remaining_raw = self.nsteps_target - self.nsteps_done
+                raw_chunk = min(chunk_size, remaining_raw)
+
+                # Convert raw chunk size to stored samples chunk size based on thin factor
+                samples_stored = max(1, raw_chunk // self.thin)
+                actual_raw = samples_stored * self.thin
+
                 b = io.StringIO()
-                self.mc.run(samples=samples, pool=pool, tqdm_kwargs={"file": b})
+                self.mc.run(samples=samples_stored, thin=self.thin, pool=pool, tqdm_kwargs={"file": b})
 
-                self.nsteps_done += samples
+                self.nsteps_done += actual_raw
                 self.q_percent_done.put(self.nsteps_done / self.nsteps_target)
                 self.q2_tqdm_out.put(b.getvalue().splitlines()[-1])
                 if self.mc.sampler is not None:

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/components/bayes.py

@@ -122,6 +122,10 @@ class BayesPanel(BaseComponent):
                             "Export to Notebook",
                             on_click=self._open_export_dialog,
                         ).classes("mt-2")
+                        self.advanced_settings_button = ui.button(
+                            "Advanced Settings",
+                            on_click=self._open_advanced_settings_dialog,
+                        ).classes("mt-2")
 
             # Control buttons
             with ui.row().classes("mt-4"):
@@ -162,6 +166,7 @@ class BayesPanel(BaseComponent):
         self.is_running = False
         self.should_stop = False
         self.completed_steps = 0
+        self.mcmc_max_points = 1000
         self.progress_timer = None
         self.status_timer = None
         self.graph_timer = None
@@ -205,8 +210,8 @@ class BayesPanel(BaseComponent):
             tau = e.tau
             if notify:
                 s = (
-                    f"Autocorrelation time is likely too short. Max tau is {int(np.max(tau))}; "
-                    f"nsteps is {self.completed_steps}. Re-run for at least {int(50 * np.max(tau))} steps."
+                    f"Autocorrelation time is likely too short. Max tau is {int(np.max(tau))* self.mcmc.thin}; "
+                    f"nsteps is {self.completed_steps} (before thinning). Re-run for at least {int(50 * np.max(tau) * self.mcmc.thin)} steps."
                 )
                 ui.notify(s, type="warning")
                 self.result_area.content += f"""
@@ -244,6 +249,16 @@ class BayesPanel(BaseComponent):
             ui.notify("No active fit result.", type="warning")
             return
 
+        ndim = self.get_ndim()
+        min_walkers = 2 * ndim
+        nwalkers = int(self.nwalkers_input.value)
+        if nwalkers < min_walkers:
+            ui.notify(
+                f"You need at least {min_walkers} parameters.",
+                type="warning",
+            )
+            return
+
         if active_fit.bd_model is None:
             logger.info("No bindtools model selected for fitting, generating one.")
             ui.notify("Running an initial fit using least_sq")
@@ -262,6 +277,9 @@ class BayesPanel(BaseComponent):
         nwalkers = int(self.nwalkers_input.value)
         obslist = self.sm.active_expt_data.get_obs_list(self.sm._expt_dtypes)
 
+        # Calculate thinning factor dynamically based on max points limit
+        thin = max(1, nsteps_target // self.mcmc_max_points)
+
         logger.info("Setting up for MCMC run")
         # Create MCMC simulation (not yet registered in state)
         self.mcmc = MCMCSim(
@@ -270,6 +288,8 @@ class BayesPanel(BaseComponent):
             bd_model=active_fit.bd_model,
             nwalkers=nwalkers,
             nsteps_target=nsteps_target,
+            thin=thin,
+            max_retained_points=self.mcmc_max_points,
             priors=list(self.prior_editor.priors) if self.prior_editor.priors else [],
         )
         self.mcmc.setup(obslist)
@@ -351,9 +371,11 @@ class BayesPanel(BaseComponent):
                 self.progress_label.text = f"MCMC Complete! ({total_steps} steps with {nwalkers} walkers)"
                 self._log_status("MCMC analysis completed successfully")
                 ui.notify("MCMC analysis completed successfully!", type="positive")
-
+                self._log_status("Generating result figures... this may take a while...")
                 # Update results
                 self._update_results(self.mcmc)
+                self._log_status("Figure generation complete!")
+
 
         except Exception as e:
             self.progress_label.text = "Analysis failed"
@@ -414,7 +436,7 @@ class BayesPanel(BaseComponent):
         
         Analysis completed at {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S")}
         """
-        self._make_result_graphs()
+        ui.timer(0, self._make_result_graphs, once=True)
 
     def _update_graphs(self):
         if hasattr(self, "mcmc"):
@@ -441,7 +463,10 @@ class BayesPanel(BaseComponent):
                     for w in walkers_to_plot:
                         axs[d].plot(chains[:, w, d], label=f"Dim {d} Walker {w}")
                         axs[d].set_title(f"Parameter {d}")
-                        axs[d].set_xlabel("Steps")
+                        if self.mcmc.thin != 1:
+                            axs[d].set_xlabel(f"Steps (thinning 1-in-{self.mcmc.thin} points)")
+                        else:
+                            axs[d].set_xlabel(f"Steps")
 
                 # Plot acceptance fraction
                 axs[-1].bar(range(nwalkers), acceptance_frac)
@@ -547,8 +572,63 @@ class BayesPanel(BaseComponent):
         ):
             self.mcmc = found_mcmc
             self._update_results(self.mcmc)
+            self.nwalkers_input.set_value(found_mcmc.nwalkers)
+            self.nsteps_input.set_value(found_mcmc.nsteps_target)
+            self.mcmc_max_points = getattr(found_mcmc, "max_retained_points", 1000)
+            ndim = self.get_ndim()
+            self.nwalkers_input.min = max(2, 2 * ndim)
+        else:
+            self.mcmc_max_points = 1000
+            self.update_default_walkers()
+
+    def get_ndim(self) -> int:
+        active_fit = self.sm.active_fit_or_none
+        if active_fit is None:
+            return 0
+
+        varying_params = 0
+        if getattr(active_fit, "params", None):
+            varying_params = sum(1 for p in active_fit.params.values() if isinstance(p, dict) and p.get("vary") is True)
+        elif active_fit.bd_model is not None:
+            if active_fit.bd_model.miniResult is not None:
+                varying_params = sum(1 for p in active_fit.bd_model.miniResult.params.values() if p.vary)
+            elif active_fit.bd_model.params is not None:
+                varying_params = sum(1 for p in active_fit.bd_model.params.values() if p.vary)
+
+        unique_dtypes = set()
+        expt_data = self.sm.active_expt_data_or_none
+        if expt_data is not None:
+            for col, details in expt_data.col_details.items():
+                if details.get("depindep") == "dep":
+                    dtype_key = details.get("dtype")
+                    if dtype_key is not None:
+                        edt = self.sm._expt_dtypes.get(dtype_key)
+                        if edt is not None:
+                            unique_dtypes.add(edt.meas)
+
+        return varying_params + len(unique_dtypes)
+
+    def update_default_walkers(self) -> None:
+        active_fit = self.sm.active_fit_or_none
+        if active_fit is None:
+            return
+
+        ndim = self.get_ndim()
+        default_walkers = 2 * ndim
+        self.nwalkers_input.min = max(2, default_walkers)
+
+        found_mcmc = self._fit_to_mcmc.get(active_fit.id)
+        if (
+            found_mcmc is not None
+            and getattr(found_mcmc, "mc", None) is not None
+            and getattr(found_mcmc.mc, "sampler", None) is not None
+        ):
+            self.nwalkers_input.set_value(found_mcmc.nwalkers)
+        else:
+            self.nwalkers_input.set_value(default_walkers)
 
-    def _make_result_graphs(self):
+
+    async def _make_result_graphs(self):
         if self.mcmc.mc.sampler is None:
             ui.notify("No chain available; re-run MCMC", type="negative")
             return
@@ -556,21 +636,26 @@ class BayesPanel(BaseComponent):
         self._apply_chain_container_style(self.result_chains, ndim)
         self._apply_corner_container_style(ndim)
 
-        f = self.result_chains.figure
-        f.clear()
+        def _plot_chain_sync(fig, mc, w, h):
+            fig.clear()
+            self._set_figure_size(fig, w, h)
+            mc.plot_chain(fig=fig)
+            fig.tight_layout()
+
         w, h = self._chain_figsize(ndim)
-        self._set_figure_size(f, w, h)
-        self.mcmc.mc.plot_chain(fig=f)
-        f.tight_layout()
+        await run.io_bound(_plot_chain_sync, self.result_chains.figure, self.mcmc.mc, w, h)
         self.result_chains.update()
 
-        f = self.result_corner.figure
-        f.clear()
-        cw, ch = self._corner_figsize(ndim)
-        self._set_figure_size(f, cw, ch)
         burnin = self._get_burnin(notify=True)
-        self.mcmc.mc.make_corner_fig(burnin=burnin, fig=f)
-        f.tight_layout()
+
+        def _plot_corner_sync(fig, mc, burnin, cw, ch):
+            fig.clear()
+            self._set_figure_size(fig, cw, ch)
+            mc.make_corner_fig(burnin=burnin, fig=fig)
+            fig.tight_layout()
+
+        cw, ch = self._corner_figsize(ndim)
+        await run.io_bound(_plot_corner_sync, self.result_corner.figure, self.mcmc.mc, burnin, cw, ch)
         self.result_corner.update()
 
     async def _download_figure(self, fig, filename: str) -> None:
@@ -583,13 +668,19 @@ class BayesPanel(BaseComponent):
         if not hasattr(self, "mcmc") or self.mcmc.mc is None or self.mcmc.mc.sampler is None:
             ui.notify("No chain figure available for download.", type="warning")
             return
+        ui.notify("Generating chain figure for download...", type="info")
         ndim = int(self.mcmc.mc.sampler.ndim)
         fig = plt.figure()
         w, h = self._chain_figsize(ndim)
         fig.set_dpi(_EXPORT_DPI)
         fig.set_size_inches(w * 1.2, h * 1.2, forward=True)
-        self.mcmc.mc.plot_chain(fig=fig)
-        fig.tight_layout()
+
+        def _plot(f, mc):
+            mc.plot_chain(fig=f)
+            f.tight_layout()
+
+        await run.io_bound(_plot, fig, self.mcmc.mc)
+
         active_fit = self.sm.active_fit_or_none
         stem = active_fit.name if active_fit is not None else "mcmc"
         filename = f"{safe_filename(stem, fallback='mcmc')}_chains.png"
@@ -600,20 +691,65 @@ class BayesPanel(BaseComponent):
         if not hasattr(self, "mcmc") or self.mcmc.mc is None or self.mcmc.mc.sampler is None:
             ui.notify("No corner figure available for download.", type="warning")
             return
+        ui.notify("Generating corner figure for download...", type="info")
         ndim = int(self.mcmc.mc.sampler.ndim)
         fig = plt.figure()
         w, h = self._corner_figsize(ndim)
         fig.set_dpi(_EXPORT_DPI)
         fig.set_size_inches(w * 1.2, h * 1.2, forward=True)
         burnin = self._get_burnin(notify=False)
-        self.mcmc.mc.make_corner_fig(burnin=burnin, fig=fig)
-        fig.tight_layout()
+
+        def _plot(f, mc, burnin):
+            mc.make_corner_fig(burnin=burnin, fig=f)
+            f.tight_layout()
+
+        await run.io_bound(_plot, fig, self.mcmc.mc, burnin)
+
         active_fit = self.sm.active_fit_or_none
         stem = active_fit.name if active_fit is not None else "mcmc"
         filename = f"{safe_filename(stem, fallback='mcmc')}_corner.png"
         await self._download_figure(fig, filename)
         plt.close(fig)
 
+    def _open_advanced_settings_dialog(self) -> None:
+        with ui.dialog() as dialog, ui.card().classes("min-w-[24rem] p-6 rounded-lg shadow-lg"):
+            ui.label("Advanced MCMC Settings").classes("text-lg font-bold mb-2")
+            ui.label("Control how MCMC chains are thinned for plotting and export.").classes("text-xs text-gray-500 mb-4")
+
+            ui.label("Max points to retain (per walker):").classes("text-sm font-semibold mb-1")
+            max_points_input = ui.number(value=self.mcmc_max_points, min=10, max=1000000).classes("w-full mb-2")
+
+            thin_label = ui.label("").classes("text-xs text-gray-500 font-medium bg-gray-50 p-2 rounded w-full")
+
+            def update_thin_factor():
+                try:
+                    nsteps = int(self.nsteps_input.value)
+                    max_pts = int(max_points_input.value or 1000)
+                    thin = max(1, nsteps // max_pts)
+                    retained = nsteps // thin
+                    thin_label.text = f"Calculated thinning factor: {thin} (retains {retained} points)"
+                except Exception:
+                    thin_label.text = "Invalid steps or points value"
+
+            max_points_input.on_value_change(update_thin_factor)
+            update_thin_factor()  # Initial update
+
+            async def save_settings():
+                self.mcmc_max_points = int(max_points_input.value or 1000)
+                # If MCMCSim exists, update its values
+                if hasattr(self, "mcmc") and self.mcmc is not None:
+                    self.mcmc.max_retained_points = self.mcmc_max_points
+                    self.mcmc.thin = max(1, self.mcmc.nsteps_target // self.mcmc_max_points)
+                    self.sm.save_to_storage()
+                dialog.close()
+                ui.notify("Advanced settings saved.", type="positive")
+
+            with ui.row().classes("mt-6 gap-2 justify-end w-full"):
+                ui.button("Cancel", on_click=dialog.close).props("flat")
+                ui.button("Save", on_click=save_settings).props("color=primary")
+
+        dialog.open()
+
     # ------------------------------------------------------------------
     # Notebook export
     # ------------------------------------------------------------------

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/components/body.py

@@ -194,6 +194,8 @@ class Body(BaseComponent):
         if e.args == "Data model setup":
             # Ensure the data model is updated when switching to the Data model setup tab
             self.components["data_model"]._populate_blocks()
+        if e.args == "MCMC":
+            self.components["mcmc"].update_default_walkers()
         if e.args == "Fit Results":
             pass
             # Ensure the fit results graph is updated when switching to the Fit Results tab

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/components/data_model.py

@@ -140,14 +140,15 @@ class DataModelPanel(BaseComponent):
 
         with self.dataModel_specInteg_block:
             self.spec_integ_inps: dict[str, ui.input] = {}
+            self.spec_integ_cbs: dict[str, ui.checkbox] = {}
             for i, spec in enumerate(self.sm.species):
                 with ui.row().classes("items-center"):
                     ui.label(f"Species conc. [{spec}]_free:")
                     self.spec_integ_inps[spec] = ui.input().classes("flex-1").props("clearable")
 
                     self.spec_integ_inps[spec].on("blur", lambda c=self.spec_integ_inps[spec]: self.set_focus(c))
-                    b = ui.checkbox("Enabled", value=True).props(f"testid=spec-enabled-{spec}")
-                    self.spec_integ_inps[spec].bind_enabled_from(b, "value")
+                    self.spec_integ_cbs[spec] = ui.checkbox("Enabled", value=True).props(f"testid=spec-enabled-{spec}")
+                    self.spec_integ_inps[spec].bind_enabled_from(self.spec_integ_cbs[spec], "value")
                     if (
                         hasattr(active_expt, "integ_to_spec")
                         and active_expt.integ_to_spec is not None
@@ -157,9 +158,9 @@ class DataModelPanel(BaseComponent):
                             active_expt.integ_to_spec[i], active_expt.columns
                         )
                         if self.spec_integ_inps[spec].value == "":
-                            b.value = False
+                            self.spec_integ_cbs[spec].value = False
                     else:
-                        b.value = False
+                        self.spec_integ_cbs[spec].value = False
 
     def _gen_spec_fast_exchange_block(self):
         """Generate the species fast exchange block.
@@ -227,95 +228,94 @@ class DataModelPanel(BaseComponent):
         self.fast_ex_chem_shift_params = []
         # map per spec-delta index -> { species_name: {card, shift_num, fixed_cb, min_num, max_num} }
         self.fast_ex_chem_shift_map = []
+        self.specDeltaCbs = []
 
         # keep the fast-exchange column names for later processing and bindings
         self.fast_ex_list_names = list(fast_ex_list)
-        if len(extra_deps) > 0:
-            with self.dataModel_specFastExchange_block:
-                # species_list = [f'{x}_free' for x in self.sm.species]
-
-                # default_shift_species = _default_analytical_shift_species(
-                #     self.sm.active_model.eq_mat,
-                #     list(self.sm.active_model.component_names),
-                #     species_list,
-                #     len(self.fast_ex_list_names),
-                # )
-                # if default_shift_species is not None:
-                #     ui.label(
-                #         f"Analytical model detected: defaulting fast-exchange expression to [{default_shift_species}] "
-                #         "for this observable. You can edit it if needed."
-                #     ).classes("text-xs text-gray-600")
-
-                for i, shift in enumerate(self.fast_ex_list_names):
-                    # card per chemical shift column
-                    card = ui.card().classes("mb-2")
-                    self.specDeltaCards.append(card)
-                    with card:
-                        ui.label(f"Fast exchange shift {i + 1} ({shift})").classes("text-sm font-semibold")
-                        with ui.row().classes("items-center"):
-                            inp = ui.input().classes("flex-1").props("clearable")
-                            self.specDeltaInps.append(inp)
-                            # species chips row will be added below the input to allow quick insertion
-                            with ui.row().classes("gap-1 mt-2"):
-                                for text in [f"{x}_free" for x in self.sm.species]:
-                                    ui.chip(
-                                        text,
-                                        color="teal",
-                                        on_click=lambda h=text: self._insert_species_into_fast_inp(h),
-                                    )
-                            # placeholder checkbox to enable the input
-                            en_cb = ui.checkbox("Enabled", value=True)
-                            inp.bind_enabled_from(en_cb, "value")
-                            # placeholder param block element (initially empty/hidden)
-                            pb = ui.element()
-                            self.fast_ex_chem_shift_blocks.append(pb)
-                            self.fast_ex_chem_shift_map.append({})
-                            # store param dict for later
-                            # self.fast_ex_chem_shift_params.append({'shift': None, 'fixed': False, 'min': None, 'max': None})
-
-                            # bind blur handler to create/update parameter block
-                            # use default args to capture current inp and index
-                            # allow chips/clicks to insert into this input by remembering last focus
-                            inp.on("focus", lambda e, widget=inp: self.set_focus(widget))
-                            inp.on("click", lambda e, widget=inp: self.set_focus(widget))
-                            # handle blur to create/update parameter sub-blocks
-                            inp.on("blur", lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
-                            # immediate change handler: reparse on every change
-                            inp.on_value_change(lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
-
-                            # if there is saved delta_to_spec data, populate the input
-                            if (
-                                hasattr(active_expt, "delta_to_spec")
-                                and active_expt.delta_to_spec is not None
-                                and len(active_expt.delta_to_spec) > 0
-                            ):
-                                delta_for_eqn = active_expt.delta_to_spec[i].copy()
-
-                                for ij, el in enumerate(delta_for_eqn):
-                                    if np.isclose(el, 0):
-                                        delta_for_eqn[ij] = 0
-                                    else:
-                                        if (f"{self.sm.species[ij]}_free", shift) in active_expt.limiting_shifts:
-                                            s = active_expt.limiting_shifts[f"{self.sm.species[ij]}_free", shift]
-                                            if s.value:
-                                                delta_for_eqn[ij] = delta_for_eqn[ij] / s.value
-                                            else:
-                                                delta_for_eqn[ij] = 1
-
-                                            # self.sm.active_expt_data.limiting_shifts[f'{self.sm.species[i]}_free',shift].value
-
-                                # delta_for_eqn[delta_for_eqn != 0] = 1
-
-                                value = self.vec_to_conc_expression(
-                                    delta_for_eqn, [f"{x}_free" for x in self.sm.species]
+        with self.dataModel_specFastExchange_block:
+            # species_list = [f'{x}_free' for x in self.sm.species]
+
+            default_shift_species = None
+            if simple_model is not None and len(simple_model[1]) > 0:
+                default_shift_species = f"{self.sm.species[simple_model[1][0]]}_free"
+
+            if default_shift_species is not None:
+                ui.label(
+                    f"Analytical model detected: defaulting fast-exchange expression to [{default_shift_species}] "
+                    "for this observable. You can edit it if needed."
+                ).classes("text-xs text-gray-600")
+
+            for i, shift in enumerate(self.fast_ex_list_names):
+                # card per chemical shift column
+                card = ui.card().classes("mb-2")
+                self.specDeltaCards.append(card)
+                with card:
+                    ui.label(f"Fast exchange shift {i + 1} ({shift})").classes("text-sm font-semibold")
+                    with ui.row().classes("items-center"):
+                        inp = ui.input().classes("flex-1").props("clearable")
+                        self.specDeltaInps.append(inp)
+                        # species chips row will be added below the input to allow quick insertion
+                        with ui.row().classes("gap-1 mt-2"):
+                            for text in [f"{x}_free" for x in self.sm.species]:
+                                ui.chip(
+                                    text,
+                                    color="teal",
+                                    on_click=lambda h=text: self._insert_species_into_fast_inp(h),
                                 )
-                                inp.value = value
-                                if value == "":
-                                    en_cb.value = False
-                            # elif default_shift_species is not None:
-                            #     inp.value = f"[{default_shift_species}]"
-                            #     # Build corresponding ChemicalShiftParam widgets immediately.
-                            #     self._handle_spec_delta_blur(i, inp)
+                        # placeholder checkbox to enable the input
+                        en_cb = ui.checkbox("Enabled", value=True)
+                        self.specDeltaCbs.append(en_cb)
+                        inp.bind_enabled_from(en_cb, "value")
+                        # placeholder param block element (initially empty/hidden)
+                        pb = ui.element()
+                        self.fast_ex_chem_shift_blocks.append(pb)
+                        self.fast_ex_chem_shift_map.append({})
+                        # store param dict for later
+                        # self.fast_ex_chem_shift_params.append({'shift': None, 'fixed': False, 'min': None, 'max': None})
+
+                        # bind blur handler to create/update parameter block
+                        # use default args to capture current inp and index
+                        # allow chips/clicks to insert into this input by remembering last focus
+                        inp.on("focus", lambda e, widget=inp: self.set_focus(widget))
+                        inp.on("click", lambda e, widget=inp: self.set_focus(widget))
+                        # handle blur to create/update parameter sub-blocks
+                        inp.on("blur", lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
+                        # immediate change handler: reparse on every change
+                        inp.on_value_change(lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
+
+                        # if there is saved delta_to_spec data, populate the input
+                        if (
+                            hasattr(active_expt, "delta_to_spec")
+                            and active_expt.delta_to_spec is not None
+                            and len(active_expt.delta_to_spec) > 0
+                        ):
+                            delta_for_eqn = active_expt.delta_to_spec[i].copy()
+
+                            for ij, el in enumerate(delta_for_eqn):
+                                if np.isclose(el, 0):
+                                    delta_for_eqn[ij] = 0
+                                else:
+                                    if (f"{self.sm.species[ij]}_free", shift) in active_expt.limiting_shifts:
+                                        s = active_expt.limiting_shifts[f"{self.sm.species[ij]}_free", shift]
+                                        if s.value:
+                                            delta_for_eqn[ij] = delta_for_eqn[ij] / s.value
+                                        else:
+                                            delta_for_eqn[ij] = 1
+
+                                        # self.sm.active_expt_data.limiting_shifts[f'{self.sm.species[i]}_free',shift].value
+
+                            # delta_for_eqn[delta_for_eqn != 0] = 1
+
+                            value = self.vec_to_conc_expression(
+                                delta_for_eqn, [f"{x}_free" for x in self.sm.species]
+                            )
+                            inp.value = value
+                            if value == "":
+                                en_cb.value = False
+                        elif default_shift_species is not None:
+                            inp.value = f"[{default_shift_species}]"
+                            # Build corresponding ChemicalShiftParam widgets immediately.
+                            self._handle_spec_delta_blur(i, inp)
 
         # finished generating fast-exchange block
 
@@ -371,6 +371,14 @@ class DataModelPanel(BaseComponent):
                 if not isinstance(cs_obj, ChemicalShiftParam):
                     # create with safe defaults
                     cs_obj = ChemicalShiftParam(species=spec_name, col=col_name, fixed=False)
+                    try:
+                        if hasattr(active_expt, "data") and active_expt.data is not None and col_name in active_expt.data.columns:
+                            first_val = float(active_expt.data[col_name].dropna().iloc[0])
+                            cs_obj.value = round(first_val, 4)
+                            cs_obj._min = round(first_val - 1.0, 4)
+                            cs_obj._max = round(first_val + 1.0, 4)
+                    except Exception:
+                        pass
                     active_expt.limiting_shifts[k] = cs_obj
 
                 # reuse if exists
@@ -463,10 +471,10 @@ class DataModelPanel(BaseComponent):
             target.integ_to_spec = None
         else:
             integ_to_spec = [
-                self.conc_expression_to_vec(input.value, target.columns)
-                if input.enabled
+                self.conc_expression_to_vec(self.spec_integ_inps[spec].value, target.columns)
+                if self.spec_integ_cbs[spec].value
                 else np.zeros(len(target.columns))
-                for input in self.spec_integ_inps.values()
+                for spec in self.sm.species
             ]
             integ_to_spec = np.array(integ_to_spec)
             if integ_to_spec.size == 0 or np.all(np.isclose(integ_to_spec, 0)):
@@ -483,9 +491,9 @@ class DataModelPanel(BaseComponent):
         if hasattr(self, "specDeltaInps") and isinstance(self.specDeltaInps, list) and len(self.specDeltaInps) > 0:
             species_label_list = [f"{s}_free" for s in self.sm.species]
             for idx, input_widget in enumerate(self.specDeltaInps):
+                cb = self.specDeltaCbs[idx]
                 if (
-                    hasattr(input_widget, "enabled")
-                    and input_widget.enabled
+                    cb.value
                     and isinstance(input_widget.value, str)
                     and input_widget.value.strip()
                 ):

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/components/fitting.py

@@ -80,6 +80,12 @@ def _prepare_fit_plot_frames(fit: FitResult) -> tuple[pd.DataFrame, pd.DataFrame
 
 
 def _infer_analytical_fast_exchange_config(model, expt_data, expt_dtypes: dict) -> dict[str, object] | None:
+    import warnings
+    warnings.warn(
+        "_infer_analytical_fast_exchange_config is deprecated. Topology detection has been relocated to bindtools.bindingModel.prepModel().",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     if model is None or expt_data is None:
         return None
 
@@ -126,8 +132,6 @@ def _infer_analytical_fast_exchange_config(model, expt_data, expt_dtypes: dict)
         return {
             "topology": topo_name,
             "complex_indices": complex_indices,
-            "obs_columns": [],  # no NMR shift columns
-            "obs_components": [],
         }
 
     # Pure NMR shift path (existing behaviour).
@@ -140,85 +144,9 @@ def _infer_analytical_fast_exchange_config(model, expt_data, expt_dtypes: dict)
         if finite.size > 0 and np.any(~np.isclose(finite, 0.0)):
             return None
 
-    component_free_labels = [f"{name}_free" for name in model.component_names]
-    if len(component_free_labels) != 2:
-        return None
-
-    # Build optional hints from existing user mappings when available.
-    shift_species_by_col: dict[str, set[str]] = {}
-    if isinstance(expt_data.limiting_shifts, dict):
-        for (species, col_name), _ in expt_data.limiting_shifts.items():
-            if col_name is None:
-                continue
-            shift_species_by_col.setdefault(str(col_name), set()).add(str(species))
-
-    delta_species_hints: dict[str, set[str]] = {}
-    delta_to_spec = expt_data.delta_to_spec
-    if isinstance(delta_to_spec, np.ndarray) and delta_to_spec.ndim == 2 and delta_to_spec.size > 0:
-        # In this UI flow, delta_to_spec rows are created from fast-exchange observable columns.
-        # For analytical mode all dependent observables are shift observables, so the row order
-        # corresponds to obs_list.
-        n_rows = min(delta_to_spec.shape[0], len(obs_list))
-        n_species = min(delta_to_spec.shape[1], len(component_free_labels))
-        for ridx in range(n_rows):
-            col_name = obs_list[ridx]
-            for sidx in range(n_species):
-                try:
-                    is_nonzero = not np.isclose(float(delta_to_spec[ridx, sidx]), 0.0)
-                except Exception:
-                    is_nonzero = bool(delta_to_spec[ridx, sidx])
-                if is_nonzero:
-                    delta_species_hints.setdefault(col_name, set()).add(component_free_labels[sidx])
-
-    def _component_from_text_hints(col_name: str, dtype_key: str | None) -> int | None:
-        # Tokenize to avoid over-matching short component names in arbitrary strings.
-        tokens = []
-        for src in (col_name, dtype_key or ""):
-            parts = [t for t in re.split(r"[^A-Za-z0-9]+", str(src).lower()) if t]
-            tokens.extend(parts)
-        matches = [idx for idx, comp in enumerate(model.component_names) if str(comp).lower() in tokens]
-        return matches[0] if len(matches) == 1 else None
-
-    obs_components: list[int] = []
-    unresolved: list[tuple[int, str]] = []
-    for obs_idx, col in enumerate(obs_list):
-        col_meta = expt_data.col_details.get(col, {})
-        dtype_key = col_meta.get("dtype")
-
-        included_species = set()
-        included_species |= shift_species_by_col.get(col, set())
-        included_species |= delta_species_hints.get(col, set())
-
-        has_comp0 = component_free_labels[0] in included_species
-        has_comp1 = component_free_labels[1] in included_species
-        if has_comp0 != has_comp1:
-            obs_components.append(0 if has_comp0 else 1)
-            continue
-
-        inferred = _component_from_text_hints(col, dtype_key)
-        if inferred is not None:
-            obs_components.append(inferred)
-            continue
-
-        unresolved.append((obs_idx, col))
-        obs_components.append(-1)
-
-    # Final fallback keeps analytical mode enabled even without manual shift metadata.
-    if unresolved:
-        for obs_idx, col in unresolved:
-            fallback = obs_idx % len(component_free_labels)
-            obs_components[obs_idx] = fallback
-            logger.info(
-                "Analytical fast-exchange: inferred observable '%s' as component %d by default fallback.",
-                col,
-                fallback,
-            )
-
     return {
         "topology": topo_name,
         "complex_indices": complex_indices,
-        "obs_columns": list(obs_list),
-        "obs_components": obs_components,
     }
 
 
@@ -229,11 +157,11 @@ class FittingPanel(BaseComponent):
 
         with self.container:
             ui.label("Fitting panel").classes("text-lg font-bold mb-4")
-            with ui.row():
-                with ui.card():
-                    ui.label("Fitting options to go here.")
+            with ui.row().classes("w-full gap-4 items-start flex-col lg:flex-row"):
+                with ui.card().classes("w-full lg:w-80 shrink-0"):
+                    # ui.label("Fitting options to go here.")
                     self.fit_alg_select = ui.select(
-                        ["least_squares", "l-bfgs", "ampgo"],
+                        ["least_squares", "l-bfgs", "l-bfgs-b", "nelder-mead", "ampgo"],
                         label="Algorithm",
                         on_change=lambda e: print(f"Selected: {e.value}"),
                         value="least_squares",
@@ -437,16 +365,8 @@ class FittingPanel(BaseComponent):
                     type="info",
                 )
 
-        analytical_cfg = _infer_analytical_fast_exchange_config(
-            self.sm.active_model,
-            self.sm.active_expt_data,
-            self.sm._expt_dtypes,
-        )
-
-
-
-        self.m1 = self.sm.generate_binding_model_for_fit(analytical_cfg=analytical_cfg)
-        if analytical_cfg is not None:
+        self.m1 = self.sm.generate_binding_model_for_fit()
+        if self.m1.analytical_fast_exchange:
             ui.notify(
                 f"Using analytical fast-exchange backend ({self.m1.analytical_topology}).",
                 type="info",
@@ -494,18 +414,8 @@ class FittingPanel(BaseComponent):
                 init_expt_data=self.sm.active_expt_data,
                 init_model=self.sm.active_model,
                 bd_model=self.m1,
-                analytical_fast_exchange=analytical_cfg is not None,
+                analytical_fast_exchange=self.m1.analytical_fast_exchange,
                 analytical_topology=self.m1.analytical_topology,
-                analytical_obs_columns=(
-                    [str(x) for x in cast(list[str], analytical_cfg["obs_columns"])]
-                    if analytical_cfg is not None
-                    else []
-                ),
-                analytical_obs_components=(
-                    [int(x) for x in cast(list[int], analytical_cfg["obs_components"])]
-                    if analytical_cfg is not None
-                    else []
-                ),
                 analytical_complex_indices=self.m1.analytical_complex_indices,
             )
             self.sm.add_fit(new_fit)
@@ -520,6 +430,11 @@ class FittingPanel(BaseComponent):
                     "initial_value": v.init_value,
                 }
 
+            print("DEBUG: specToInteg =", self.sm.active_expt_data.integ_to_spec)
+            print("DEBUG: specToDd =", self.sm.active_expt_data.delta_to_spec)
+            print("DEBUG: obsList =", self.m1.obsList)
+            print("DEBUG: calc_obs shape =", np.shape(calc_obs))
+
             self.sm.active_fit.calc_obs = pd.DataFrame(calc_obs, columns=self.m1.obsList)
 
             self.sm.active_fit.fit_speciation = pd.DataFrame(speciation, columns=[x + "_free" for x in self.sm.species])
@@ -718,7 +633,7 @@ class FittingPanel(BaseComponent):
 class FitResultsCard(BaseComponent):
     def setup_nicegui(self) -> None:
 
-        with ui.card():
+        with ui.card().classes("w-full lg:flex-1 min-w-0 overflow-hidden"):
             # ui.label("Fitting Results to go here.")
             with ui.row().classes("w-full"):
                 ui.label("Results:")
@@ -785,7 +700,14 @@ class FitResultsCard(BaseComponent):
 
         fitParams = list(dict.fromkeys(fitParams))  # Remove duplicates
 
-        paramCols = [{"name": param, "label": param, "field": param} for param in fitParams]
+        paramCols = [
+            {
+                "name": param,
+                "label": f"logK({param[3:]})" if param.startswith("log") else param,
+                "field": param,
+            }
+            for param in fitParams
+        ]
 
         stat_col_names = {"chisqr", "aic", "bic", "message", "covariance"}
         stat_cols = [c for c in self.default_columns if c["name"] in stat_col_names]
@@ -803,7 +725,7 @@ class FitResultsCard(BaseComponent):
         for fit in self.sm.fits.values():
             row = {
                 "name": fit.name,
-                "chisqr": self.rounded_value(fit.chisqr),
+                "chisqr": self.rounded_value(fit.chisqr,scientific=True),
                 "aic": self.rounded_value(fit.aic, dp=1),
                 "bic": self.rounded_value(fit.bic, dp=1),
                 "message": fit.termination_message,
@@ -820,10 +742,10 @@ class FitResultsCard(BaseComponent):
         self.add_body_slot()
         self.table.update()
 
-    def rounded_value(self, value: float, dp: int = 3) -> str:
+    def rounded_value(self, value: float, dp: int = 3, scientific=False) -> str:
         """Round the value for display."""
-        if abs(value) >= 10000 or abs(value) < 0.001:
-            return f"{value:.4e}"
+        if abs(value) >= 10000 or abs(value) < 0.001 or scientific:
+            return f"{value:.3e}"
         else:
             return f"{value:.{dp}f}" if isinstance(value, float) else str(value)
 

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/export/notebook_exporter.py

@@ -239,17 +239,7 @@ def _build_lin_obs_cell4_lines(
     return lines
 
 
-def _build_analytical_lin_obs_lines(lin_obs_param_map: list) -> list[str]:
-    """Return setup lines for the analytical path's linear_obs_param_map.
 
-    Extracts the param name (or None) from each cell so
-    fitfun_analytical_fast_exchange can call calc_analytical_linear_observables.
-    """
-    # Serialise as [[name_or_none, ...], ...]
-    name_map = [[cell["name"] if cell is not None else None for cell in row] for row in lin_obs_param_map]
-    return [
-        f"m.analytical_linear_obs_param_map = {name_map!r}",
-    ]
 
 
 def export_fit_notebook(
@@ -382,7 +372,31 @@ def export_fit_notebook(
         spec_to_integ_arg = "None"
 
     if has_delta:
-        spec_to_dd_line = f"spec_to_dd = np.array({delta_to_spec.T.tolist()!r}, dtype=object)"
+        # Build spec_to_dd reconstruction lines dynamically to properly instantiate lmfit.Parameters
+        spec_to_dd_lines = [
+            "spec_to_dd = np.empty((len(species_names), len(obs_list)), dtype=object)"
+        ]
+        delta_T = delta_to_spec.T
+        for i in range(delta_T.shape[0]):
+            for j in range(delta_T.shape[1]):
+                cell = delta_T[i, j]
+                if cell is None:
+                    spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = None")
+                elif isinstance(cell, (int, float, np.floating)):
+                    if np.isnan(cell):
+                        spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = None")
+                    else:
+                        spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = {float(cell)!r}")
+                else: # lmfit.Parameter
+                    pname = getattr(cell, "name", "")
+                    pval = getattr(cell, "value", 0.0)
+                    pmin = getattr(cell, "min", -np.inf)
+                    pmax = getattr(cell, "max", np.inf)
+                    pvary = getattr(cell, "vary", True)
+                    spec_to_dd_lines.append(
+                        f"spec_to_dd[{i}, {j}] = lmfit.Parameter({pname!r}, value={pval!r}, min={pmin!r}, max={pmax!r}, vary={pvary!r})"
+                    )
+        spec_to_dd_line = "\n".join(spec_to_dd_lines)
         spec_to_dd_arg = "spec_to_dd"
     else:
         spec_to_dd_line = "spec_to_dd = None"
@@ -390,8 +404,6 @@ def export_fit_notebook(
 
     is_analytical = bool(getattr(fit, "analytical_fast_exchange", False))
     analytical_topology = getattr(fit, "analytical_topology", None)
-    analytical_obs_columns = list(getattr(fit, "analytical_obs_columns", []))
-    analytical_obs_components = list(getattr(fit, "analytical_obs_components", []))
     analytical_complex_indices = list(getattr(fit, "analytical_complex_indices", []))
 
     has_lin_obs = bool(lin_obs_col_names and lin_obs_param_map)
@@ -399,15 +411,11 @@ def export_fit_notebook(
     if is_analytical:
         analytical_setup_lines: list[str] = [
             "",
-            "# Analytical fast-exchange backend — must be configured before prepModel()",
+            "# Analytical fast-exchange speciation",
             "m.analytical_fast_exchange = True",
             f"m.analytical_topology = {analytical_topology!r}",
-            f"m.analytical_obs_columns = {analytical_obs_columns!r}",
-            f"m.analytical_obs_components = {analytical_obs_components!r}",
             f"m.analytical_complex_indices = {analytical_complex_indices!r}",
         ]
-        if has_lin_obs:
-            analytical_setup_lines += _build_analytical_lin_obs_lines(lin_obs_param_map)  # type: ignore[arg-type]
     else:
         analytical_setup_lines = []
 
@@ -659,6 +667,7 @@ def export_mcmc_notebook(
                 f"with h5py.File('{stem}_chains.hdf', 'r') as f:",
                 "    chain    = f['mcmc/chain'][:]     # (nsteps, nwalkers, ndim)",
                 "    log_prob = f['mcmc/log_prob'][:]  # (nsteps, nwalkers)",
+                "    thin     = f['mcmc'].attrs.get('thin', 1)",
                 "",
                 "param_labels = [p for p in m.params if m.params[p].vary]",
                 "ndim = chain.shape[2]",
@@ -671,7 +680,10 @@ def export_mcmc_notebook(
                 "    axes[i].set_ylabel(label)",
                 "axes[-1].plot(log_prob, alpha=0.3, lw=0.5, color='k')",
                 "axes[-1].set_ylabel('log prob')",
-                "axes[-1].set_xlabel('step')",
+                "if thin != 1:",
+                "    axes[-1].set_xlabel(f'step (thinning 1-in-{thin} points)')",
+                "else:",
+                "    axes[-1].set_xlabel('step')",
                 "fig.tight_layout()",
                 "plt.show()",
                 "",
@@ -738,6 +750,7 @@ def export_mcmc_notebook(
             if has_blobs:
                 g.create_dataset("blobs", data=backend.blobs)
             g.attrs["iteration"] = backend.iteration
+            g.attrs["thin"] = thin
             hf.flush()
             h5_bytes = bytes(hf.id.get_file_image())
 

{bindmc-0.1.5 → bindmc-0.1.7}/src/bindmc/webgui/state/statemanager.py

@@ -1111,6 +1111,7 @@ class StateManager:
                         "model_id": str(m.model_id) if m.model_id else None,
                         "expt_data_id": str(m.expt_data_id) if m.expt_data_id else None,
                         "nsteps_done": m.nsteps_done,
+                        "max_retained_points": m.max_retained_points,
                     }
                     for m in self.mcmcs.values()
                 ]
@@ -1166,6 +1167,9 @@ class StateManager:
         fittemp = data.get("fits", [])  # List of fits
         if fittemp:
             for fit in fittemp:
+                # backward compatibility to load pre-0.1.7 fits
+                fit.pop("analytical_obs_columns",None)
+                fit.pop("analytical_obs_components",None)
                 fit_result = FitResult(**fit)
                 fit_result.fit_speciation = pd.DataFrame(fit.get("fit_speciation", {}))
                 fit_result.calc_obs = pd.DataFrame(fit.get("calc_obs", {}))
@@ -1232,7 +1236,7 @@ class StateManager:
                                 parameter.vary = bool(cell.get("vary", True))
                                 reconstructed_row.append(parameter)
                             elif cell is None:
-                                reconstructed_row.append(0.0)
+                                reconstructed_row.append(None)
                             elif isinstance(cell, (str, int, float)):
                                 try:
                                     reconstructed_row.append(float(cell))
@@ -1691,7 +1695,10 @@ bd.makeFitResidPlot(fit,plotMask=(0,1),ylabel='Chemical shift (ppm)')"""
         # return model_str
 
     def generate_binding_model_for_fit(
-        self, fit: Optional[FitResult] = None, analytical_cfg: Optional[dict[str, object]] = None
+        self,
+        fit: Optional[FitResult] = None,
+        analytical_cfg: Optional[dict[str, object]] = None,
+        force_numerical: bool = False,
     ) -> bd.bindingModel:
         """Generate a bindtools.bindingModel from the current active model."""
         old_fit = None
@@ -1732,16 +1739,12 @@ bd.makeFitResidPlot(fit,plotMask=(0,1),ylabel='Chemical shift (ppm)')"""
             cfg = {
                 "topology": fit.analytical_topology,
                 "complex_indices": list(getattr(fit, "analytical_complex_indices", [])),
-                "obs_columns": list(getattr(fit, "analytical_obs_columns", [])),
-                "obs_components": list(getattr(fit, "analytical_obs_components", [])),
             }
 
         if cfg is not None:
             model.analytical_fast_exchange = True
             model.analytical_topology = str(cfg["topology"])
             model.analytical_complex_indices = [int(x) for x in cfg["complex_indices"]]  # type: ignore[index]
-            model.analytical_obs_columns = [str(x) for x in cfg["obs_columns"]]  # type: ignore[index]
-            model.analytical_obs_components = [int(x) for x in cfg["obs_components"]]  # type: ignore[index]
             logger.info(
                 "Using analytical fast-exchange backend (%s model) for fitting.",
                 model.analytical_topology,
@@ -1777,17 +1780,7 @@ bd.makeFitResidPlot(fit,plotMask=(0,1),ylabel='Chemical shift (ppm)')"""
                 model.analytical_linear_obs_columns = lin_cols
                 model.analytical_linear_obs_param_map = linear_obs_param_map
 
-        # Always infer topology to allow analytical concentrations in slow exchange
-        from bindmc.webgui.utils import _infer_simple_fast_exchange_topology
-        topology_res = _infer_simple_fast_exchange_topology(
-            self.active_model.eq_mat, len(self.active_model.component_names)
-        )
-        if topology_res is not None:
-            topo_name, complex_indices = topology_res
-            model.analytical_topology = topo_name
-            model.analytical_complex_indices = complex_indices
-
-        model.prepModel()
+        model.prepModel(force_numerical=force_numerical)
 
         for k in self.active_model.binding_constants:
             model.params[f"log{k.species}"].set(