bindmc 0.1.0__py3-none-any.whl

bindmc/webgui/classes/FitResult.py

@@ -0,0 +1,173 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+from .Model import Model
+from .ExptData import ExptData
+import bindtools.binding as bd
+
+@dataclass 
+class FitResult:
+    """Data class to represent the results of a fit."""
+    model_id: uuid.UUID   # The modelUID used for the fit
+    expt_data_id: uuid.UUID   # The experimental data used for the fit, if any
+    name: str  # Name of the fit result
+    description: str  # Description of the fit result
+    aic: float   # Akaike Information Criterion for the fit
+    bic: float  # Bayesian Information Criterion for the fit
+    chisqr: float  # Chi-squared value for the fit
+    termination_message: str  # Message indicating the termination status of the fit
+    fit_method: str = 'least_squares' # method used in the fit e.g. least_sq
+    success: Any = False  # Whether the fit was successful
+    fit_speciation: pd.DataFrame = field(default_factory=pd.DataFrame, compare=False)  # DataFrame to hold output species concentrations
+    calc_obs: pd.DataFrame = field(default_factory=pd.DataFrame, compare=False)  # Calculated observations from the fit
+    id: uuid.UUID = field(default_factory=lambda: (uuid.uuid4()))
+    params: dict = field(default_factory=dict)   # List of binding constants and other parameters
+    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
+    init_expt_data: InitVar[Optional[ExptData]] = None  # The
+
+    _model: Optional[Model] = None  # The model used for the fit, if any
+    _expt_data: Optional[ExptData] = None  # The experimental data used for the fit, if any
+
+
+
+    def __post_init__(self,init_model,init_expt_data):
+        """Ensure data are appropriate types."""
+        if isinstance(init_model,Model):
+            self._model = init_model
+            self.model_id = init_model.id
+        if isinstance(init_expt_data, ExptData):
+            self._expt_data = init_expt_data
+            self.expt_data_id = init_expt_data.id
+
+
+        if not isinstance(self.expt_data_id, uuid.UUID):
+            if isinstance(self.expt_data_id, str):
+                self.expt_data_id = uuid.UUID(self.expt_data_id)
+        
+        if not isinstance(self.model_id, uuid.UUID):
+            if isinstance(self.model_id, str):
+                self.model_id = uuid.UUID(self.model_id)
+
+        if not isinstance(self.id, uuid.UUID):
+            if isinstance(self.id, str):
+                self.id = uuid.UUID(self.id)
+
+        if isinstance(self._expt_data,ExptData) and not self.expt_data_id:
+            self.expt_data_id = self._expt_data.id
+
+        if isinstance(self._model, Model) and not self.model_id:
+            self.model_id = self._model.id
+
+    def __eq__(self,other):
+        if not isinstance(other, FitResult):
+            return False
+        
+        return self.id == other.id
+
+    def find_and_link_expt_data(self, expt_datas: dict[uuid.UUID,ExptData]) -> None:
+        """Link the experimental data to this fit result."""
+        if expt_datas is not None:
+            if self.expt_data_id in expt_datas and self.expt_data_id is not None:
+                self._expt_data = expt_datas[self.expt_data_id]
+                return
+        else:
+            raise ValueError(f"Corresponding experimental data {self.expt_data_id} not found for FitResult.")
+
+    def find_and_link_model(self, models: dict[uuid.UUID,Model]) -> None:
+        """Link the experimental data to this fit result."""
+        if models is not None:
+            if self.model_id in models and self.model_id is not None:
+                self._model = models[self.model_id]
+                return
+        else:
+            raise ValueError(f"Corresponding model {self.model_id} not found for FitResult.")
+
+
+    @property
+    def comp_concs(self) -> pd.DataFrame:
+        """Get the component concentrations for this fit."""
+        if self._expt_data:
+            return self._expt_data.comp_concs
+        else:
+            raise ValueError("ExptData is not set or does not have component concentrations.")
+        
+    @property
+    def model(self) -> Model:
+        """Get the model associated with this fit."""
+        if hasattr(self, "_model") and isinstance(self._model, Model):
+            return self._model
+        else:
+            raise ValueError("Model is not set for FitResult.")
+       
+    
+    @model.setter
+    def model(self, model: Model) -> None:
+        """Set the model for this fit."""
+        if model is not None:
+            self.model_id = model.id
+            self._model = model
+        else:
+            raise ValueError("Model cannot be None for FitResult.")
+    
+    @property
+    def expt_data(self) -> ExptData:
+        """Get the experimental data associated with this fit."""
+        if hasattr(self, "_expt_data") and isinstance(self._expt_data, ExptData):
+            return self._expt_data 
+        else:
+            raise ValueError("ExptData is not set for FitResult.")
+    
+    @expt_data.setter
+    def expt_data(self, expt_data: ExptData) -> None:
+        """Set the experimental data for this fit."""
+        if expt_data is not None:
+            self.expt_data_id = expt_data.id
+            self._expt_data = expt_data
+        else:
+            raise ValueError("ExptData cannot be None for FitResult.")
+
+    def to_dict(self) -> dict[str, str|dict|list|bool|float|None]:
+        """Convert FitResult to a dictionary."""
+        return {
+            "model_id": str(self.model_id) if self.model_id else "",
+            "expt_data_id": str(self.expt_data_id) if self.expt_data_id else None,
+            "id": str(self.id) if self.id else "",
+            "name": self.name,
+            "description": self.description,
+            "params": self.params if isinstance(self.params, dict) else {},
+            "aic": self.aic,
+            "bic": self.bic,
+            "chisqr": self.chisqr,
+            "fit_method": self.fit_method,
+            "termination_message": self.termination_message,
+            "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 {}
+            ),
+            "calc_obs": (
+                self.calc_obs.to_dict(orient="list")
+                if isinstance(self.calc_obs, pd.DataFrame)
+                else {}
+            ),
+        }
+    
+  

bindmc/webgui/classes/MCMCSim.py

@@ -0,0 +1,232 @@
+import io
+import logging
+import uuid
+from dataclasses import dataclass, field, InitVar
+from typing import Any, Optional
+
+from nicegui import run
+import numpy as np
+import bindtools.binding as bd
+from functools import partial
+from multiprocessing import Manager, Pool
+
+from .ExptData import ExptData
+from .Model import Model
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class MCMCSim:
+    """Data class to represent a MCMC simulation."""
+    nwalkers: int = 100
+    nsteps_target: int = 1000
+
+    burn: int = 100
+    thin: int = 1
+    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)
+    model_id: Optional[uuid.UUID] = None
+    expt_data_id: Optional[uuid.UUID] = None
+    nsteps_done: int = 0
+    bd_model: Optional[bd.bindingModel] = None
+
+
+    model: InitVar[Optional[Model]] = None
+    expt_data: InitVar[Optional[ExptData]] = None
+
+    id: uuid.UUID = field(
+        default_factory=lambda: (uuid.uuid4())
+    )  # unique ID for the instance
+
+    def __post_init__(self,model,expt_data) -> None:
+        """Ensure data are appropriate types."""
+        if not isinstance(self.id, uuid.UUID):
+            if isinstance(self.id, str):
+                self.id = uuid.UUID(self.id)
+
+        prior_specs: list[dict[str, Any]] = []
+        for prior in self.priors or []:
+            if not isinstance(prior, dict):
+                continue
+            prior_type = str(prior.get("type", "uniform")).lower()
+            params = prior.get("params")
+            if not isinstance(params, dict):
+                params = {
+                    key: prior.get(key)
+                    for key in ("lower", "upper", "mu", "sigma")
+                    if prior.get(key) is not None
+                }
+            prior_specs.append(
+                {
+                    "label": str(prior.get("label", "")),
+                    "type": prior_type,
+                    "params": dict(params),
+                }
+            )
+        self.priors = prior_specs
+        
+        if model is not None:
+            self.model_id = model.id
+            self._model = model
+        else:
+            self._model = None 
+        if expt_data is not None:
+            self.expt_data_id = expt_data.id
+            self._expt_data = expt_data
+        else:
+            self._expt_data = None
+        
+        manager = Manager()
+        self.cancel_event = manager.Event()
+        self.q_percent_done = manager.Queue()
+        self.q2_tqdm_out = manager.Queue()
+        self.q3_samples = manager.Queue()
+        self.chunk_size_val = manager.Value('i', 100)
+
+
+    def find_and_link_expt_data(self, expt_datas: dict[uuid.UUID,ExptData]) -> None:
+        """Link the experimental data to this fit result."""
+        if expt_datas is not None:
+            if self.expt_data_id in expt_datas and self.expt_data_id is not None:
+                self._expt_data = expt_datas[self.expt_data_id]
+                return
+        else:
+            raise ValueError(f"Corresponding experimental data {self.expt_data_id} not found for FitResult.")
+
+    def find_and_link_model(self, models: dict[uuid.UUID,Model]) -> None:
+        """Link the experimental data to this fit result."""
+        if models is not None:
+            if self.model_id in models and self.model_id is not None:
+                self._model = models[self.model_id]
+                return
+        else:
+            raise ValueError(f"Corresponding model {self.model_id} not found for FitResult.")
+
+
+
+    def setup(self,obslist: list[bd.ObsType]) -> None:
+        if self.bd_model is None:
+            raise ValueError("bd_model must be set before running MCMC simulation.")
+        if self._expt_data is None:
+            raise ValueError("Experimental data must be linked before running MCMC simulation.")
+
+        self.mc = bd.MCMC(self.bd_model, obslist, walkers=self.nwalkers, samples=self.nsteps_target)
+        self._apply_prior_bounds(obslist)
+
+    def _parameter_specs(self, obslist: list[bd.ObsType]) -> list[dict[str, Any]]:
+        if self.bd_model is None or self.bd_model.miniResult is None:
+            return []
+
+        specs: list[dict[str, Any]] = []
+        mini_result_params = getattr(self.bd_model.miniResult, "params", None)
+        if mini_result_params is None:
+            return []
+
+        for param_name in mini_result_params.keys():
+            if not mini_result_params[param_name].vary:
+                continue
+            param = self.bd_model.params[param_name]
+            specs.append(
+                {
+                    "label": str(getattr(param, "name", param_name)),
+                    "lower": float(param.min),
+                    "upper": float(param.max),
+                }
+            )
+
+        seen_sigma_names: set[str] = set()
+        for obs in obslist:
+            if obs.name in seen_sigma_names:
+                continue
+            seen_sigma_names.add(obs.name)
+            sigma_param = obs.param
+            specs.append(
+                {
+                    "label": str(getattr(sigma_param, "name", obs.name)),
+                    "lower": float(sigma_param.min),
+                    "upper": float(sigma_param.max),
+                }
+            )
+
+        return specs
+
+    def _apply_prior_bounds(self, obslist: list[bd.ObsType]) -> None:
+        if self.bd_model is None:
+            return
+
+        specs = self._parameter_specs(obslist)
+        resolved_bounds: list[list[float]] = []
+        for index, spec in enumerate(specs):
+            prior = self.priors[index] if index < len(self.priors) else {}
+            prior_type = str(prior.get("type", "uniform")).lower()
+            params = prior.get("params", {}) if isinstance(prior.get("params", {}), dict) else {}
+            lower = params.get("lower", spec["lower"])
+            upper = params.get("upper", spec["upper"])
+            if prior_type != "uniform":
+                if prior_type not in ('none', ''):
+                    logger.warning(
+                        "Unsupported prior type '%s' for '%s'; falling back to model bounds.",
+                        prior_type,
+                        spec.get("label", f"param_{index}"),
+                    )
+                lower = spec["lower"]
+                upper = spec["upper"]
+
+            try:
+                lower_value = float(spec["lower"] if lower is None else lower)
+            except (TypeError, ValueError):
+                lower_value = float(spec["lower"])
+            try:
+                upper_value = float(spec["upper"] if upper is None else upper)
+            except (TypeError, ValueError):
+                upper_value = float(spec["upper"])
+
+            resolved_bounds.append([lower_value, upper_value])
+
+        if not hasattr(self.bd_model, "fcn_opts") or self.bd_model.fcn_opts is None:
+            self.bd_model.fcn_opts = {}
+        self.bd_model.fcn_opts["mcmc_bounds"] = np.array(resolved_bounds, dtype=float)
+
+    async def run(self,chunk_size: Optional[int]=None) -> None:
+        if chunk_size is not None:
+            self.chunk_size_val.value = int(chunk_size)
+        self.mc = await run.cpu_bound(partial(self._run_mcmc))
+
+    
+    def _run_mcmc(self) -> bd.MCMC:
+        """Run the MCMC simulation with multiprocessing in blocks of chunk_size steps."""
+        if self.mc is None:
+            raise ValueError("MCMC not set up. Call setup() before running the simulation.")
+        
+        with Pool() as pool:
+            while self.nsteps_done < self.nsteps_target:
+                if self.cancel_event.is_set():
+                    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)
+                b = io.StringIO()
+                self.mc.run(samples=samples,pool=pool,tqdm_kwargs={'file': b})
+
+
+
+                self.nsteps_done += samples
+                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:
+                    a={}
+                    # a['percent_done'] = self.nsteps_done / self.nsteps_target
+                    # a['tqdm'] = b.getvalue().splitlines()[-1]
+                    a['chains'] = self.mc.sampler.get_chain()#discard=self.burn, thin=self.thin, flat=True)
+                    a['acceptance_fraction'] = self.mc.sampler.acceptance_fraction
+                    self.q3_samples.put(a)
+                logger.info('Completed steps: %s', self.nsteps_done)
+            
+
+
+            
+
+        return self.mc

bindmc/webgui/classes/Model.py

@@ -0,0 +1,86 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+from .Component import Component
+from .BindingConstant import BindingConstant
+
+@dataclass
+class Model:
+    """Data class to represent a model."""
+
+    name: str = ""
+    eq_str: str = ""
+    eq_mat_str: str = ""
+    eq_mat: np.ndarray = field(
+        default_factory=lambda: np.array([])
+    )  # List of numpy arrays for the equilibrium matrix # TODO this should just be an array
+    nComp: int = 2
+    nStep: int = 20
+    components: list[Component] = field(default_factory=list)
+    binding_constants: list[BindingConstant] = field(default_factory=list)
+    results: np.ndarray = field(default_factory=lambda: np.array([]))
+    species: list[str] = field(default_factory=list)
+    component_names: list[str] = field(default_factory=list)
+    component_concs: pd.DataFrame = field(
+        default_factory=pd.DataFrame, compare=False
+    )  # compare=False means that __eq__ does not try to do a dataframe comparison, which tends to fail
+    id: uuid.UUID = field(
+        default_factory=lambda: (uuid.uuid4()))
+
+    def __post_init__(self):
+        """Ensure data are appropriate types."""
+        if not isinstance(self.id, uuid.UUID):
+            if isinstance(self.id, str):
+                self.id = uuid.UUID(self.id)
+
+    def to_dict(self):
+        """Convert Model to a dictionary."""
+        return {
+            "name": self.name,
+            "eq_str": self.eq_str,
+            "eq_mat_str": str(self.eq_mat_str) if self.eq_mat_str else "",
+            "eq_mat": (
+                self.eq_mat.tolist() if isinstance(self.eq_mat, np.ndarray) else []
+            ),  # Convert numpy arrays to lists
+            "nComp": int(self.nComp),
+            "nStep": int(self.nStep),
+            "components": (
+                [asdict(comp) for comp in self.components]
+                if len(self.components) > 0
+                else []
+            ),
+            "binding_constants": (
+                [asdict(k) for k in self.binding_constants]
+                if len(self.binding_constants) > 0
+                else []
+            ),
+            "results": self.results.tolist() if hasattr(self,'results') and len(self.results)>0 else [],
+            "species": self.species if self.species else [],
+            "component_names": self.component_names if self.component_names else [],
+            "component_concs": (
+                self.component_concs.to_dict()
+                if isinstance(self.component_concs, pd.DataFrame)
+                else {}
+            ),
+            "id": str(self.id),
+        }
+
+    @property
+    def fullCompSpecList(self) -> list[str]:
+        """Get the full list of component and species names."""
+        return [s + "_tot" for s in self.component_names] + [
+            s + "_free" for s in self.species
+        ]
+    
+
+    def __eq__(self,other):
+        if not isinstance(other, Model):
+            return False
+        
+        return self.id == other.id
+

bindmc/webgui/classes/RawData.py

@@ -0,0 +1,36 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+
+
+@dataclass
+class RawData:
+    filename: str = ""
+    data: pd.DataFrame = field(default_factory=pd.DataFrame, compare=False)
+    id: uuid.UUID = field(default_factory= lambda: uuid.uuid4())
+
+    def __post_init__(self):
+        """Ensure data are appropriate types."""
+        if not isinstance(self.id, uuid.UUID):
+            if isinstance(self.id, str):
+                self.id = uuid.UUID(self.id)
+
+
+    def to_dict(self) -> dict[str, str|dict]:
+        """Convert RawData to a dictionary."""
+        return {
+            "filename": self.filename,
+            "data": (
+                self.data.to_dict(orient="list")
+                if isinstance(self.data, pd.DataFrame)
+                else {}
+            ),
+            "id": str(self.id) if self.id else "",
+        }
+
+

bindmc/webgui/classes/Simulation.py

@@ -0,0 +1,104 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+from .BindingConstant import BindingConstant
+from .Model import Model
+
+
+@dataclass
+class Simulation:
+    """Data class to represent a simulation, which comprises:
+    - input data (component concentrations or analogous generators)
+    - a model (consider separating into a binding model and a data model,
+                where the former has parameters of binding constants only, the latter of datafile<=>concentration
+                conversions etc.)
+    - params (comprising at minimum a list of binding constants)
+    - output data (speies concentrations)"""
+
+    comp_concs: pd.DataFrame = field(
+        default_factory=pd.DataFrame, compare=False
+    )  # compare=False means that __eq__ does not try to do a dataframe comparison, which tends to fail
+    model_id: uuid.UUID | None = None  # The modelUID used for the simulation
+    params: list[BindingConstant] = field(
+        default_factory=list
+    )  # List of binding constants and other parameters
+    results: pd.DataFrame = field(
+        default_factory=pd.DataFrame
+    )  # DataFrame to hold output species concentrations
+    id: uuid.UUID = field(
+        default_factory=lambda: (uuid.uuid4())
+    )  # unique ID for the instance
+    comment: str = ""  # Optional comment for the simulation
+    name: str = ""
+
+    def __post_init__(self):
+        """Ensure data are appropriate types."""
+        if not isinstance(self.id, uuid.UUID):
+            if isinstance(self.id, str):
+                self.id = uuid.UUID(self.id)
+        
+        if not isinstance(self.model_id,uuid.UUID):
+            if isinstance(self.model_id, str):
+                self.model_id = uuid.UUID(self.model_id)
+
+        # deep copy dataframes to avoid issues with mutability
+        if isinstance(self.comp_concs, pd.DataFrame):
+            self.comp_concs = self.comp_concs.copy()
+        if isinstance(self.results, pd.DataFrame):
+            self.results = self.results.copy()
+
+    def to_dict(self) -> dict[str, str|dict|list]:
+        return {
+            "comp_concs": (
+                self.comp_concs.to_dict()
+                if isinstance(self.comp_concs, pd.DataFrame)
+                else {}
+            ),
+            "model_id": str(self.model_id) if self.model_id else "",
+            "params": [asdict(k) for k in self.params] if len(self.params) > 0 else [],
+            "results": (
+                self.results.to_dict(orient="list")
+                if isinstance(self.results, pd.DataFrame)
+                else {}
+            ),
+            "id": str(self.id),
+            "comment": self.comment,
+            "name": self.name,
+        }
+
+    @property
+    def model(self) -> Optional[Model]:
+        """Get the model associated with this simulation."""
+        return self._model if hasattr(self, "_model") else None
+
+    @model.setter
+    def model(self, model: Model) -> None:
+        """Set the model for this simulation."""
+        if model is not None:
+            self.model_id = model.id
+            self._model = model
+        else:
+            self.model_id = None
+            self._model = None
+
+    def find_and_link_model(self, models: Optional[dict[uuid.UUID,Model]] = None) -> None:
+        """Set the model for this simulation."""
+        if models is not None:
+            if self.model_id in models and self.model_id is not None:
+                self._model = models[self.model_id]
+            else:
+                raise ValueError(f"Corresponding model {self.model_id} not found for Simulation.")
+
+
+
+    def __eq__(self,other):
+        if not isinstance(other, Simulation):
+            return False
+        
+        return self.id == other.id
+

bindmc/webgui/classes/UIBindings.py

@@ -0,0 +1,19 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+
+@binding.bindable_dataclass
+@dataclass
+class UIBindings:
+    """Helper class to hold UI bindings."""
+    model_name: str = ""
+    raw_data_name: str = ""
+    data_model_name: str = ""
+    fit_name: str = ""
+    sim_name: str = ""
+ 

bindmc/webgui/classes/__init__.py

@@ -0,0 +1,28 @@
+# webgui/classes/__init__.py
+from .BindingConstant import BindingConstant
+from .Component import Component
+from .Model import Model
+from .RawData import RawData
+from .ChemicalShiftParam import ChemicalShiftParam
+from .ExptData import ExptData
+from .ExptDataType import ExptDataType
+from .FitResult import FitResult
+from .Simulation import Simulation
+from .MCMCSim import MCMCSim
+from .UIBindings import UIBindings
+
+
+__all__ = [
+    "BindingConstant",
+    "Component",
+    "Model",
+    "RawData",
+    "ChemicalShiftParam",
+    "ExptData",
+    "FitResult",
+    "Simulation",
+    "MCMCSim", 
+    "ExptDataType",
+    "UIBindings" 
+
+]