AMS-BP 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

AMS_BP/gui/widgets/channel_config_widget.py

@@ -0,0 +1,307 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+from PyQt6.QtWidgets import (
+    QComboBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class ChannelConfigWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.channel_widgets = []
+
+        layout = QVBoxLayout()
+        form = QFormLayout()
+
+        self.validate_button = QPushButton("Validate")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
+        self.num_channels = QSpinBox()
+        self.num_channels.setRange(1, 10)
+        self.num_channels.setValue(2)
+        self.num_channels.valueChanged.connect(self.update_channel_tabs)
+        form.addRow("Number of Channels:", self.num_channels)
+
+        self.channel_tabs = QTabWidget()
+        self.update_channel_tabs()
+
+        layout.addLayout(form)
+        layout.addWidget(self.channel_tabs)
+        self.setLayout(layout)
+
+    def validate(self) -> bool:
+        try:
+            from ...configio.convertconfig import create_channels
+
+            data = self.get_data()
+
+            # Full simulation-level validation
+            channels = create_channels({"channels": data})
+
+            # Optional: Validate shape consistency
+            if len(channels.names) != channels.num_channels:
+                raise ValueError("Channel count does not match number of names.")
+
+            QMessageBox.information(
+                self, "Validation Successful", "Channel parameters are valid."
+            )
+            return True
+
+        except (ValidationError, ValueError, KeyError) as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+        except Exception as e:
+            QMessageBox.critical(self, "Unexpected Error", str(e))
+            return False
+
+    def update_channel_tabs(self):
+        self.channel_tabs.clear()
+        self.channel_widgets = []
+
+        for i in range(self.num_channels.value()):
+            self.add_channel_tab(i)
+
+        self.channel_tabs.setCurrentIndex(0)
+
+    def add_channel_tab(self, index):
+        tab = QWidget()
+        layout = QFormLayout()
+
+        # Channel name
+        channel_name = QLineEdit()
+        layout.addRow(f"Channel {index + 1} Name:", channel_name)
+
+        # Split efficiency
+        split_eff = QDoubleSpinBox()
+        split_eff.setRange(0.0, 1.0)
+        split_eff.setValue(1.0)
+        layout.addRow(f"Channel {index + 1} Split Efficiency:", split_eff)
+
+        # Excitation filter
+        exc_name = QLineEdit()
+        exc_type = QComboBox()
+        exc_type.addItems(["bandpass", "allow_all"])
+        exc_center = QSpinBox()
+        exc_center.setRange(0, 10000)
+        exc_bandwidth = QSpinBox()
+        exc_bandwidth.setRange(0, 10000)
+        exc_trans = QDoubleSpinBox()
+        exc_trans.setRange(0.0, 1.0)
+        exc_points = QSpinBox()
+        exc_points.setRange(1, 10000)
+
+        layout.addRow("Excitation Name:", exc_name)
+        layout.addRow("Excitation Type:", exc_type)
+        layout.addRow("Excitation Center (nm):", exc_center)
+        layout.addRow("Excitation Bandwidth (nm):", exc_bandwidth)
+        layout.addRow("Excitation Transmission Peak:", exc_trans)
+        layout.addRow("Excitation Points:", exc_points)
+
+        # Emission filter
+        em_name = QLineEdit()
+        em_type = QComboBox()
+        em_type.addItems(["bandpass", "allow_all"])
+        em_center = QSpinBox()
+        em_center.setRange(0, 10000)
+        em_bandwidth = QSpinBox()
+        em_bandwidth.setRange(0, 10000)
+        em_trans = QDoubleSpinBox()
+        em_trans.setRange(0.0, 1.0)
+        em_points = QSpinBox()
+        em_points.setRange(1, 10000)
+
+        exc_type.currentTextChanged.connect(
+            lambda val: self.toggle_filter_fields(
+                val, exc_center, exc_bandwidth, exc_trans, exc_points
+            )
+        )
+        em_type.currentTextChanged.connect(
+            lambda val: self.toggle_filter_fields(
+                val, em_center, em_bandwidth, em_trans, em_points
+            )
+        )
+
+        # Call once to initialize visibility
+        self.toggle_filter_fields(
+            exc_type.currentText(), exc_center, exc_bandwidth, exc_trans, exc_points
+        )
+        self.toggle_filter_fields(
+            em_type.currentText(), em_center, em_bandwidth, em_trans, em_points
+        )
+
+        layout.addRow("Emission Name:", em_name)
+        layout.addRow("Emission Type:", em_type)
+        layout.addRow("Emission Center (nm):", em_center)
+        layout.addRow("Emission Bandwidth (nm):", em_bandwidth)
+        layout.addRow("Emission Transmission Peak:", em_trans)
+        layout.addRow("Emission Points:", em_points)
+
+        tab.setLayout(layout)
+        self.channel_tabs.addTab(tab, f"Channel {index + 1}")
+
+        # Store all widget references
+        widgets = {
+            "channel_name": channel_name,
+            "split_efficiency": split_eff,
+            "exc_name": exc_name,
+            "exc_type": exc_type,
+            "exc_center": exc_center,
+            "exc_bandwidth": exc_bandwidth,
+            "exc_trans": exc_trans,
+            "exc_points": exc_points,
+            "em_name": em_name,
+            "em_type": em_type,
+            "em_center": em_center,
+            "em_bandwidth": em_bandwidth,
+            "em_trans": em_trans,
+            "em_points": em_points,
+        }
+
+        self.channel_widgets.append(widgets)
+
+    def toggle_filter_fields(
+        self,
+        filter_type,
+        center_field,
+        bandwidth_field,
+        transmission_field,
+        points_field,
+    ):
+        is_allow_all = filter_type == "allow_all"
+        center_field.setEnabled(not is_allow_all)
+        bandwidth_field.setEnabled(not is_allow_all)
+        transmission_field.setEnabled(not is_allow_all)
+        points_field.setEnabled(not is_allow_all)
+
+    def get_data(self) -> dict:
+        num_channels = self.num_channels.value()
+        data = {
+            "num_of_channels": num_channels,
+            "channel_names": [],
+            "split_efficiency": [],
+            "filters": {},
+        }
+
+        for i, widgets in enumerate(self.channel_widgets):
+            name = widgets["channel_name"].text().strip()
+            if not name:
+                raise ValueError(f"Channel {i + 1} name is required.")
+
+            data["channel_names"].append(name)
+            data["split_efficiency"].append(widgets["split_efficiency"].value())
+
+            # Excitation
+            exc_type = widgets["exc_type"].currentText()
+            excitation = {
+                "name": widgets["exc_name"].text(),
+                "type": exc_type,
+            }
+            if exc_type == "bandpass":
+                excitation.update(
+                    {
+                        "center_wavelength": widgets["exc_center"].value(),
+                        "bandwidth": widgets["exc_bandwidth"].value(),
+                        "transmission_peak": widgets["exc_trans"].value(),
+                        "points": widgets["exc_points"].value(),
+                    }
+                )
+            else:
+                excitation["points"] = widgets["exc_points"].value()
+
+            # Emission
+            em_type = widgets["em_type"].currentText()
+            emission = {
+                "name": widgets["em_name"].text(),
+                "type": em_type,
+            }
+            if em_type == "bandpass":
+                emission.update(
+                    {
+                        "center_wavelength": widgets["em_center"].value(),
+                        "bandwidth": widgets["em_bandwidth"].value(),
+                        "transmission_peak": widgets["em_trans"].value(),
+                        "points": widgets["em_points"].value(),
+                    }
+                )
+            else:
+                emission["points"] = widgets["em_points"].value()
+
+            data["filters"][name] = {
+                "filter_set_name": f"{name.capitalize()} Filter Set",
+                "filter_set_description": f"Sample {name.capitalize()} filter set configuration",
+                "excitation": excitation,
+                "emission": emission,
+            }
+
+        return data
+
+    def set_data(self, data: dict):
+        num_channels = data.get("num_of_channels", 0)
+        self.num_channels.setValue(num_channels)
+        self.update_channel_tabs()
+
+        channel_names = data.get("channel_names", [])
+        split_efficiencies = data.get("split_efficiency", [])
+        filters = data.get("filters", {})
+
+        for i, widgets in enumerate(self.channel_widgets):
+            if i >= len(channel_names):
+                break
+
+            name = channel_names[i]
+            widgets["channel_name"].setText(name)
+
+            if i < len(split_efficiencies):
+                widgets["split_efficiency"].setValue(split_efficiencies[i])
+
+            filter_data = filters.get(name, {})
+
+            # Excitation
+            excitation = filter_data.get("excitation", {})
+            widgets["exc_name"].setText(excitation.get("name", ""))
+            widgets["exc_type"].setCurrentText(excitation.get("type", "bandpass"))
+
+            widgets["exc_center"].setValue(excitation.get("center_wavelength", 0))
+            widgets["exc_bandwidth"].setValue(excitation.get("bandwidth", 0))
+            widgets["exc_trans"].setValue(excitation.get("transmission_peak", 0.0))
+            widgets["exc_points"].setValue(excitation.get("points", 1))
+
+            # Emission
+            emission = filter_data.get("emission", {})
+            widgets["em_name"].setText(emission.get("name", ""))
+            widgets["em_type"].setCurrentText(emission.get("type", "bandpass"))
+
+            widgets["em_center"].setValue(emission.get("center_wavelength", 0))
+            widgets["em_bandwidth"].setValue(emission.get("bandwidth", 0))
+            widgets["em_trans"].setValue(emission.get("transmission_peak", 0.0))
+            widgets["em_points"].setValue(emission.get("points", 1))
+
+            # Apply visibility logic
+            self.toggle_filter_fields(
+                widgets["exc_type"].currentText(),
+                widgets["exc_center"],
+                widgets["exc_bandwidth"],
+                widgets["exc_trans"],
+                widgets["exc_points"],
+            )
+            self.toggle_filter_fields(
+                widgets["em_type"].currentText(),
+                widgets["em_center"],
+                widgets["em_bandwidth"],
+                widgets["em_trans"],
+                widgets["em_points"],
+            )
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "channels_help.md"

AMS_BP/gui/widgets/condensate_config_widget.py

@@ -0,0 +1,341 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QDoubleSpinBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QSpinBox,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class CondensateConfigWidget(QWidget):
+    # Signal to notify when molecule count changes
+    molecule_count_changed = pyqtSignal(int)
+
+    def __init__(self):
+        super().__init__()
+        self.molecule_tabs = []
+        self.condensate_widgets = []
+        self._updating_molecule_count = False  # Flag to prevent recursion
+        self.setup_ui()
+
+    def setup_ui(self):
+        layout = QVBoxLayout()
+
+        # Instructions label
+        instructions = QLabel(
+            "Configure parameters for different molecule types and their condensates. "
+            "Each tab represents a different molecule type."
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Controls for adding/removing molecule types
+        controls_layout = QHBoxLayout()
+
+        self.molecule_count = QSpinBox()
+        self.molecule_count.setRange(1, 10)
+        self.molecule_count.setValue(1)
+        self.molecule_count.valueChanged.connect(self._on_molecule_count_changed)
+        controls_layout.addWidget(QLabel("Number of Molecule Types:"))
+        controls_layout.addWidget(self.molecule_count)
+
+        layout.addLayout(controls_layout)
+
+        # Tab widget for molecule types
+        self.tab_widget = QTabWidget()
+        layout.addWidget(self.tab_widget)
+
+        # Validation button
+        self.validate_button = QPushButton("Validate Parameters")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
+        # Initialize with one molecule type
+        self.update_molecule_count(1)
+
+        self.setLayout(layout)
+
+    def _on_molecule_count_changed(self, count):
+        """Handle molecule count change internally and emit signal"""
+        if not self._updating_molecule_count:
+            self.update_molecule_count(count)
+            # Emit signal to notify other widgets
+            self.molecule_count_changed.emit(count)
+
+    def set_molecule_count(self, count):
+        """Public method to be called by other widgets to update molecule count"""
+        if self.molecule_count.value() != count:
+            self._updating_molecule_count = True
+            self.molecule_count.setValue(count)
+            self.update_molecule_count(count)
+            self._updating_molecule_count = False
+
+    def update_molecule_count(self, count):
+        """Update the number of molecule tabs"""
+        current_count = self.tab_widget.count()
+
+        # Add new tabs if needed
+        for i in range(current_count, count):
+            self.add_molecule_tab(i)
+
+        # Remove excess tabs if needed
+        while self.tab_widget.count() > count:
+            self.tab_widget.removeTab(count)
+            if self.condensate_widgets:
+                self.condensate_widgets.pop()
+
+    def add_molecule_tab(self, index):
+        """Add a new tab for a molecule type"""
+        molecule_widget = QWidget()
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+
+        layout = QVBoxLayout(molecule_widget)
+
+        # Controls for condensate count
+        condensate_controls = QHBoxLayout()
+        condensate_count = QSpinBox()
+        condensate_count.setRange(1, 20)
+        condensate_count.setValue(1)
+
+        condensate_controls.addWidget(QLabel("Number of Condensates:"))
+        condensate_controls.addWidget(condensate_count)
+        layout.addLayout(condensate_controls)
+
+        condensate_container = QVBoxLayout()
+        layout.addLayout(condensate_container)
+
+        # Add first condensate
+        condensate_widgets = []
+        self.add_condensate_group(0, condensate_widgets, condensate_container)
+
+        condensate_count.valueChanged.connect(
+            lambda count: self.update_condensate_count(
+                count, condensate_widgets, condensate_container
+            )
+        )
+
+        # Density Difference per molecule type
+        density_layout = QHBoxLayout()
+        density_layout.addWidget(QLabel("Density Difference:"))
+
+        density_spin = QDoubleSpinBox()
+        density_spin.setRange(0, 100)
+        density_spin.setValue(1.0)
+        density_spin.setDecimals(3)
+        density_layout.addWidget(density_spin)
+        layout.addLayout(density_layout)
+        self.condensate_widgets.append(
+            {
+                "condensates": condensate_widgets,
+                "density_widget": density_spin,
+            }
+        )
+        molecule_widget.setLayout(layout)
+        scroll_area.setWidget(molecule_widget)
+
+        self.tab_widget.addTab(scroll_area, f"Molecule Type {index + 1}")
+
+    def add_condensate_group(self, index, condensate_widgets, condensate_container):
+        """Add a group of widgets for a single condensate"""
+        group = QGroupBox(f"Condensate {index + 1}")
+        form = QFormLayout()
+
+        # Initial center
+        center_layout = QHBoxLayout()
+        center_x = QDoubleSpinBox()
+        center_y = QDoubleSpinBox()
+        center_z = QDoubleSpinBox()
+
+        for spinbox in [center_x, center_y, center_z]:
+            spinbox.setRange(-1000, 1000)
+            spinbox.setDecimals(2)
+            spinbox.setSuffix(" μm")
+            center_layout.addWidget(spinbox)
+
+        form.addRow("Initial Center (x, y, z):", self._make_container(center_layout))
+
+        # Initial scale
+        scale = QDoubleSpinBox()
+        scale.setRange(0.01, 100)
+        scale.setValue(1.0)
+        scale.setDecimals(2)
+        scale.setSuffix(" μm")
+        form.addRow("Initial Scale:", scale)
+
+        # Diffusion coefficient
+        diffusion = QDoubleSpinBox()
+        diffusion.setRange(0, 100)
+        diffusion.setValue(1.0)
+        diffusion.setDecimals(3)
+        diffusion.setSuffix(" μm²/s")
+        form.addRow("Diffusion Coefficient:", diffusion)
+
+        # Hurst exponent
+        hurst = QDoubleSpinBox()
+        hurst.setRange(0, 1)
+        hurst.setValue(0.5)
+        hurst.setDecimals(2)
+        form.addRow("Hurst Exponent:", hurst)
+
+        group.setLayout(form)
+
+        condensate_container.addWidget(group)
+
+        # Store the widgets
+        condensate_data = {
+            "center": [center_x, center_y, center_z],
+            "scale": scale,
+            "diffusion": diffusion,
+            "hurst": hurst,
+            "group": group,
+        }
+        condensate_widgets.append(condensate_data)
+
+    def update_condensate_count(self, count, condensate_widgets, condensate_container):
+        """Update the number of condensate groups"""
+        current_count = len(condensate_widgets)
+
+        # Add new condensates if needed
+        for i in range(current_count, count):
+            self.add_condensate_group(i, condensate_widgets, condensate_container)
+
+        # Remove excess condensates if needed
+        while len(condensate_widgets) > count:
+            removed = condensate_widgets.pop()
+            removed["group"].deleteLater()
+
+    def _make_container(self, layout):
+        """Helper to create a container widget for a layout"""
+        container = QWidget()
+        container.setLayout(layout)
+        return container
+
+    def set_data(self, data: dict):
+        num_molecule_types = len(data["initial_centers"])
+        self.set_molecule_count(num_molecule_types)
+
+        for i in range(num_molecule_types):
+            molecule_group = self.condensate_widgets[i]
+
+            centers = data["initial_centers"][i]
+            scales = data["initial_scale"][i]
+            diffusions = data["diffusion_coefficient"][i]
+            hursts = data["hurst_exponent"][i]
+            density = data["density_dif"][i]
+
+            num_condensates = len(centers)
+            molecule_group_layout = self.tab_widget.widget(i).widget().layout()
+            self.update_condensate_count(
+                num_condensates,
+                molecule_group["condensates"],
+                molecule_group_layout,
+            )
+
+            for j in range(num_condensates):
+                condensate = molecule_group["condensates"][j]
+                for k in range(3):
+                    condensate["center"][k].setValue(centers[j][k])
+                condensate["scale"].setValue(scales[j])
+                condensate["diffusion"].setValue(diffusions[j])
+                condensate["hurst"].setValue(hursts[j])
+
+            molecule_group["density_widget"].setValue(density)
+
+    def get_data(self) -> dict:
+        initial_centers: list[list[list[float]]] = []
+        initial_scale: list[list[float]] = []
+        diffusion_coefficient: list[list[float]] = []
+        hurst_exponent: list[list[float]] = []
+        density_dif: list[float] = []
+
+        for molecule_group in self.condensate_widgets:
+            molecule_widgets = molecule_group["condensates"]
+            density_spin = molecule_group["density_widget"]
+
+            molecule_centers: list[list[float]] = []
+            molecule_scales: list[float] = []
+            molecule_diffusions: list[float] = []
+            molecule_hursts: list[float] = []
+
+            for condensate in molecule_widgets:
+                center = [spin.value() for spin in condensate["center"]]
+                molecule_centers.append(center)
+                molecule_scales.append(condensate["scale"].value())
+                molecule_diffusions.append(condensate["diffusion"].value())
+                molecule_hursts.append(condensate["hurst"].value())
+
+            initial_centers.append(molecule_centers or [[]])
+            initial_scale.append(molecule_scales or [0.0])
+            diffusion_coefficient.append(molecule_diffusions or [0.0])
+            hurst_exponent.append(molecule_hursts or [0.0])
+            density_dif.append(density_spin.value())
+
+        return {
+            "initial_centers": initial_centers,
+            "initial_scale": initial_scale,
+            "diffusion_coefficient": diffusion_coefficient,
+            "hurst_exponent": hurst_exponent,
+            "density_dif": density_dif,
+        }
+
+    def validate(self) -> bool:
+        from ...cells import create_cell
+        from ...configio.configmodels import CondensateParameters
+        from ...motion import create_condensate_dict
+
+        try:
+            data = self.get_data()
+
+            # Step 1: Validate with Pydantic
+            validated = CondensateParameters(**data)
+
+            # Step 2: Validate simulation compatibility for each condensate
+            # Create a dummy cell just for validation context
+            dummy_cell = create_cell(
+                "SphericalCell", {"center": [0, 0, 0], "radius": 5.0}
+            )
+
+            num_molecules = len(validated.initial_centers)
+
+            for i in range(num_molecules):
+                centers = validated.initial_centers[i]
+                scales = validated.initial_scale[i]
+                diffs = validated.diffusion_coefficient[i]
+                hursts = validated.hurst_exponent[i]
+
+                if not (len(centers) == len(scales) == len(diffs) == len(hursts)):
+                    raise ValueError(f"Mismatch in lengths for molecule type {i + 1}.")
+                create_condensate_dict(
+                    initial_centers=centers,
+                    initial_scale=scales,
+                    diffusion_coefficient=diffs,
+                    hurst_exponent=hursts,
+                    cell=dummy_cell,
+                )
+
+            QMessageBox.information(
+                self, "Validation Successful", "Condensate parameters are valid."
+            )
+            return True
+
+        except ValidationError as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+        except Exception as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "condensate_help.md"