bindmc 0.1.4__tar.gz → 0.1.6__tar.gz

{bindmc-0.1.4 → bindmc-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindmc
-Version: 0.1.4
+Version: 0.1.6
 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.1
 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

{bindmc-0.1.4 → bindmc-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindmc"
-version = "0.1.4"
+version = "0.1.6"
 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.1",
     "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.4 → bindmc-0.1.6}/src/bindmc/__main__.py

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

{bindmc-0.1.4 → bindmc-0.1.6}/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)
 
-if __name__ == "__main__":
-    ui.run(title="BindMC", reload=reload, native=native_mode, port=native.find_open_port(), storage_secret="bindmc_secret")
+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__"}:
+    main()
+
 
 

{bindmc-0.1.4 → bindmc-0.1.6}/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.4 → bindmc-0.1.6}/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,8 +249,18 @@ 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:
-            print("No bindtools model selected for fitting, generating one.")
+            logger.info("No bindtools model selected for fitting, generating one.")
             ui.notify("Running an initial fit using least_sq")
             m1 = self.sm.generate_binding_model_for_fit(active_fit)
             m1 = await run.cpu_bound(
@@ -262,6 +277,10 @@ 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(
             model=self.sm.active_model,
@@ -269,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)
@@ -281,12 +302,13 @@ class BayesPanel(BaseComponent):
                 type="info",
                 timeout=60000,
             )
+            logger.info("Running a trial run")
             try:
                 trial_elapsed = await run.cpu_bound(partial(_run_mcmc_trial, self.mcmc.mc, _TRIAL_STEPS))
                 it_s = _TRIAL_STEPS / trial_elapsed
                 full_seconds = nsteps_target * trial_elapsed / _TRIAL_STEPS
                 full_time_str = _format_duration(full_seconds)
-
+                logger.info("Trial run finished; took {trial_elapsed:.1f} s ({it_s:.2f} it/s).")
                 with ui.dialog() as timing_dialog, ui.card().classes("w-[min(560px,92vw)]"):
                     ui.label("Runtime estimate").classes("text-lg font-bold")
                     ui.label(f"{_TRIAL_STEPS:,} steps took {trial_elapsed:.1f} s ({it_s:.2f} it/s).").classes(
@@ -296,6 +318,8 @@ class BayesPanel(BaseComponent):
                         f"The full run ({nsteps_target:,} steps, {nwalkers} walkers) "
                         f"will take approximately {full_time_str}."
                     ).classes("mt-2")
+                    logger.info(f"The full run ({nsteps_target:,} steps, {nwalkers} walkers) "
+                        f"will take approximately {full_time_str}.")
                     ui.label("Do you want to continue?").classes("mt-1 font-medium")
                     with ui.row().classes("w-full justify-end gap-2 mt-3"):
                         ui.button("Cancel", on_click=lambda: timing_dialog.submit(False))
@@ -320,6 +344,7 @@ class BayesPanel(BaseComponent):
         self.run_button.set_enabled(False)
         self.stop_button.set_enabled(True)
         self.progress_bar.value = 0
+        logger.info("Starting MCMC analysis")
         self.progress_label.text = "Starting MCMC analysis..."
         self._log_status("Starting MCMC analysis...")
         self._start_run_timers()
@@ -346,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"
@@ -409,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"):
@@ -436,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)
@@ -542,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
 
-    def _make_result_graphs(self):
+        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)
+
+
+    async def _make_result_graphs(self):
         if self.mcmc.mc.sampler is None:
             ui.notify("No chain available; re-run MCMC", type="negative")
             return
@@ -551,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:
@@ -578,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"
@@ -595,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.4 → bindmc-0.1.6}/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.4 → bindmc-0.1.6}/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
 
@@ -229,8 +235,8 @@ class FittingPanel(BaseComponent):
 
         with self.container:
             ui.label("Fitting panel").classes("text-lg font-bold mb-4")
-            with ui.row():
-                with ui.card():
+            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"],
@@ -437,16 +443,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 +492,10 @@ 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_obs_columns=[str(x) for x in self.m1.analytical_obs_columns],
+                analytical_obs_components=[int(x) for x in self.m1.analytical_obs_components],
                 analytical_complex_indices=self.m1.analytical_complex_indices,
             )
             self.sm.add_fit(new_fit)
@@ -535,7 +525,7 @@ class FittingPanel(BaseComponent):
 
     def _update_fit_graphs(self, e=None) -> None:
         """Update the fit results display."""
-        print("Updating fit results...")
+        logger.info("Updating fit results...")
         self.fit_graph.clear_graph(update=False)
         if len(self.sm.fits) > 0:
             self.speciation_graph.clear_graph(update=False)
@@ -718,7 +708,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 +775,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]

{bindmc-0.1.4 → bindmc-0.1.6}/src/bindmc/webgui/export/notebook_exporter.py

@@ -659,6 +659,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 +672,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 +742,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.4 → bindmc-0.1.6}/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()
                 ]
@@ -1691,7 +1692,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
@@ -1777,17 +1781,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(