[WIP] Working on Package

Author: hannahlanzrath

cadetgui/cadetprocessadapter.py

@@ -8,9 +8,12 @@
     ComponentSystem,
     GeneralRateModel,
     LumpedRateModelWithPores,
+    LumpedRateModelWithoutPores,
     Cstr
 )
 
+from CADETProcess.modelBuilder import LWE, BatchElution, CLR, FlipFlop, MRSSR
+
 FieldKind = str
 Validator = Callable[[Any], None]
 Transform = Callable[[Any], Any]
@@ -47,15 +50,22 @@ def parse_float_list(v: Any) -> list[float]:
     "c_feed": FieldSpec("c_feed", "float_list", "Feed concentration", [1.0], transform=parse_float_list),
     "c_load": FieldSpec("c_load", "float_list", "Load concentration", [1.0], transform=parse_float_list),
     "c_salt_low": FieldSpec("c_salt_low", "float_list", "Low-salt buffer", [0.0], transform=parse_float_list),
-    "c_salt_high": FieldSpec("c_salt_high", "float_list", "High-salt buffer", [1.0], transform=parse_float_list),
-    "flow_rate": FieldSpec("flow_rate", "float", "Flow rate", 1.0, validate=require_positive),
+    "c_salt_high": FieldSpec("c_salt_high", "float_list", "High-salt buffer", [0.0], transform=parse_float_list),
+    "flow_rate": FieldSpec("flow_rate", "float", "Flow rate", 1.0e-6, validate=require_positive),
     "feed_duration": FieldSpec("feed_duration", "float", "Feed duration", 10.0, validate=require_positive),
     "load_duration": FieldSpec("load_duration", "float", "Load duration", 10.0, validate=require_positive),
     "cycle_time": FieldSpec("cycle_time", "float", "Cycle time", 100.0, validate=require_positive),
     "wash_duration": FieldSpec("wash_duration", "float", "Wash duration", 10.0, validate=require_positive),
     "gradient_duration": FieldSpec("gradient_duration", "float", "Gradient duration", 30.0, validate=require_positive),
     "final_wash_duration": FieldSpec("final_wash_duration", "float", "Final wash duration", 0.0),
     "c_eluent": FieldSpec("c_eluent", "float", "Eluent (scalar)", 0.0),
+    "recycle_off":   FieldSpec("recycle_off",   "float", "Recycle off (t)",  30.0,  validate=require_positive),
+    "pump_volume":   FieldSpec("pump_volume",   "float", "Pump volume",      1e-9,  validate=require_positive),
+    "delay_flip":       FieldSpec("delay_flip",       "float", "Delay flip (t)",       5.0,  validate=require_positive),
+    "delay_injection":  FieldSpec("delay_injection",  "float", "Delay injection (t)",  5.0,  validate=require_positive),
+    "c_tank_init":   FieldSpec("c_tank_init",   "float_list", "Initial tank c",transform=parse_float_list)
+
+
 }
 
 
@@ -72,8 +82,6 @@ def _pick(keys: Sequence[str]) -> list[FieldSpec]:
 
 def batch_elution_spec(column: ChromatographicColumnBase) -> ModelSpec:
     def _build(v: Mapping[str, Any]) -> Any:
-        # Import here to keep module import cheap
-        from CADETProcess.modelBuilder import BatchElution
         return BatchElution(
             column=column,
             c_feed=v["c_feed"],
@@ -92,7 +100,6 @@ def _build(v: Mapping[str, Any]) -> Any:
 
 def lwe_spec(column: ChromatographicColumnBase) -> ModelSpec:
     def _build(v: Mapping[str, Any]) -> Any:
-        from CADETProcess.modelBuilder import LWE
         return LWE(
             column=column,
             c_load=v["c_load"],
@@ -114,31 +121,122 @@ def _build(v: Mapping[str, Any]) -> Any:
         ]),
         build=_build,
     )
+    
+def clr_spec(column: ChromatographicColumnBase) -> ModelSpec:
+    """Closed Loop Recycling (CLR) spec."""
+    def _build(v: Mapping[str, Any]) -> Any:
+        from CADETProcess.modelBuilder import CLR
+        return CLR(
+            column=column,
+            c_feed=v["c_feed"],
+            flow_rate=float(v["flow_rate"]),
+            feed_duration=float(v["feed_duration"]),
+            recycle_off=float(v["recycle_off"]),
+            cycle_time=float(v["cycle_time"]),
+            c_eluent=float(v["c_eluent"]),     
+            pump_volume=float(v["pump_volume"]),
+        )
+
+    return ModelSpec(
+        title="Closed Loop Recycling (CLR)",
+        fields=_pick([
+            "c_feed",
+            "flow_rate",
+            "feed_duration",
+            "recycle_off",
+            "cycle_time",
+            "c_eluent",
+            "pump_volume",
+        ]),
+        build=_build,
+    )
+
+def flipflop_spec(column: ChromatographicColumnBase) -> ModelSpec:
+    """Flip-Flop spec."""
+    def _build(v: Mapping[str, Any]) -> Any:
+        from CADETProcess.modelBuilder import FlipFlop
+        return FlipFlop(
+            column=column,
+            c_feed=v["c_feed"],
+            flow_rate=float(v["flow_rate"]),
+            feed_duration=float(v["feed_duration"]),
+            delay_flip=float(v["delay_flip"]),
+            delay_injection=float(v["delay_injection"]),
+            c_eluent=float(v["c_eluent"]),     # keep scalar eluent for now
+        )
+
+    return ModelSpec(
+        title="Flip-Flop",
+        fields=_pick([
+            "c_feed",
+            "flow_rate",
+            "feed_duration",
+            "delay_flip",
+            "delay_injection",
+            "c_eluent",
+        ]),
+        build=_build,
+    )
+    
+def mrssr_spec(column: ChromatographicColumnBase) -> ModelSpec:
+    """Mixed-Recycle Steady-State Recycling (MRSSR) spec."""
+    def _build(v: Mapping[str, Any]) -> Any:
+        from CADETProcess.modelBuilder import MRSSR
+        # c_tank_init may be None (means: use feed concentration)
+        return MRSSR(
+            column=column,
+            c_feed=v["c_feed"],
+            flow_rate=float(v["flow_rate"]),
+            feed_duration=float(v["feed_duration"]),
+            recycle_on=float(v["recycle_on"]),
+            recycle_off=float(v["recycle_off"]),
+            cycle_time=float(v["cycle_time"]),
+            V_tank=float(v["V_tank"]),
+            c_eluent=float(v["c_eluent"]),     
+            c_tank_init=v["c_tank_init"],    
+        )
+
+    return ModelSpec(
+        title="MRSSR",
+        fields=_pick([
+            "c_feed",
+            "flow_rate",
+            "feed_duration",
+            "recycle_on",
+            "recycle_off",
+            "cycle_time",
+            "V_tank",
+            "c_eluent",
+            "c_tank_init",
+        ]),
+        build=_build,
+    )
+
+
 
 
-# A simple registry the UI can use to populate the model picker.
-# Keys are user-facing names; values are callables: (column) -> ModelSpec
 MODEL_REGISTRY: dict[str, Callable[[ChromatographicColumnBase], ModelSpec]] = {
     "Batch Elution": batch_elution_spec,
     "Load–Wash–Elute (LWE)": lwe_spec,
-    # Add more later, e.g. "SMB": smb_spec, ...
+    "CLR": clr_spec,
+    "Flip-Flop": flipflop_spec,
+    "MRSSR": mrssr_spec,
 }
 
-
-# ---- Column factories (receive a ComponentSystem and return a column) ----
 ColumnFactory = Callable[[ComponentSystem], ChromatographicColumnBase]
 
 
 def make_grm(cs: ComponentSystem) -> ChromatographicColumnBase:
     col = GeneralRateModel(cs, name="GRM")
-    # Set minimal required parameters as needed, e.g.:
-    # col.length = 0.10
     return col
 
 
 def make_lrmp(cs: ComponentSystem) -> ChromatographicColumnBase:
     col = LumpedRateModelWithPores(cs, name="LRMP")
-    # col.length = 0.05
+    return col
+
+def make_lrm(cs: ComponentSystem) -> ChromatographicColumnBase:
+    col = LumpedRateModelWithoutPores(cs, name="LRMP")
     return col
 
 
@@ -151,59 +249,115 @@ def make_cstr(cs: ComponentSystem) -> ChromatographicColumnBase:
 DEFAULT_COLUMN_FACTORIES: Dict[str, ColumnFactory] = {
     "GRM": make_grm,
     "LRMP": make_lrmp,
+    "LRM": make_lrm,
     "CSTR": make_cstr,
-    # "TubularReactor": make_tubular(...),
-    # "MCT": make_mct(...),
+
 }
 
-# --- Dynamic column configuration from required_parameters ---
+PARAM_TYPE_OVERRIDES: Dict[str, FieldKind] = {}
 
-# Optional overrides: parameter name -> FieldKind (e.g., "float", "float_list", "bool", "text")
-# For now we default everything to "float", but you can override per name here.
-PARAM_TYPE_OVERRIDES: Dict[str, FieldKind] = {
-    # "length": "float",
-    # "diameter": "float",
-    # "porosity_bed": "float",
-    # "porosity_pore": "float",
-    # "volume": "float",
-}
+def _unique_preserve_order(names: Sequence[str]) -> list[str]:
+    """Return names in original order, dropping duplicates (first occurrence wins)."""
+    seen: set[str] = set()
+    out: list[str] = []
+    for n in names:
+        if n not in seen:
+            seen.add(n)
+            out.append(n)
+    return out
 
-def column_spec_from_required(column: ChromatographicColumnBase) -> ModelSpec:
+def build_column_config_spec(column: ChromatographicColumnBase) -> ModelSpec:
     """
-    Build a ModelSpec for a column by reflecting over column.required_parameters.
-    Defaults each field to kind='float' unless overridden in PARAM_TYPE_OVERRIDES.
-    Uses the current attribute value as the default if present.
+    Build a ModelSpec for a column by reflecting over `column.required_parameters`.
+
+    - De-duplicates parameter names while preserving order.
+    - Infers kind from the current attribute value:
+        * list/tuple  -> "float_list" (uses parse_float_list)
+        * bool        -> "bool"
+        * otherwise   -> "float" (default)
+      (You can still override per name via PARAM_TYPE_OVERRIDES.)
+    - Uses the column's current attribute value as the default (when present).
     """
+
+    def _unique_preserve_order(names: Sequence[str]) -> list[str]:
+        seen: set[str] = set()
+        out: list[str] = []
+        for n in names:
+            if n not in seen:
+                seen.add(n)
+                out.append(n)
+        return out
+
     req = getattr(column, "required_parameters", None)
     if not req:
-        # Fallback: nothing to configure
         return ModelSpec(
             title=f"Configure {column.__class__.__name__}",
             fields=[],
             build=lambda _v: column,
         )
 
+    names = _unique_preserve_order(list(req))
     fields: list[FieldSpec] = []
-    for name in req:
-        kind = PARAM_TYPE_OVERRIDES.get(name, "float")  # default everything to float for now
+
+    for name in names:
         default = getattr(column, name, None)
+
+        # Default kind from overrides, else infer from current value
+        kind = PARAM_TYPE_OVERRIDES.get(name)
+        if kind is None:
+            if isinstance(default, (list, tuple)):
+                kind = "float_list"
+            elif isinstance(default, bool):
+                kind = "bool"
+            else:
+                # treat numbers/strings/None as float for now
+                kind = "float"
+
         label = name.replace("_", " ").capitalize()
-        # You can extend with validation/transform per kind if you like.
-        fields.append(FieldSpec(name=name, kind=kind, label=label, default=default))
+
+        # Attach transform for lists so the renderer feeds us a parsed list
+        transform = parse_float_list if kind == "float_list" else None
+
+        fields.append(
+            FieldSpec(
+                name=name,
+                kind=kind,
+                label=label,
+                default=default,
+                transform=transform,
+            )
+        )
 
     def _apply(v: Mapping[str, Any]) -> Any:
-        # Assign back to the column
-        for name in req:
-            if name in v:
-                try:
-                    if PARAM_TYPE_OVERRIDES.get(name, "float") == "float":
-                        setattr(column, name, float(v[name]))
+        for name in names:
+            if name not in v:
+                continue
+            try:
+                kind = PARAM_TYPE_OVERRIDES.get(name)
+                if kind is None:
+                    # infer again in case overrides are not set
+                    cur = getattr(column, name, None)
+                    if isinstance(cur, (list, tuple)):
+                        kind = "float_list"
+                    elif isinstance(cur, bool):
+                        kind = "bool"
                     else:
-                        # room for future kinds
-                        setattr(column, name, v[name])
-                except Exception:
-                    # keep going even if a parameter fails to set
-                    pass
+                        kind = "float"
+
+                val = v[name]
+                if kind == "float_list":
+                    # val may already be a list (thanks to transform), but normalize anyway
+                    val = parse_float_list(val)
+                elif kind == "bool":
+                    val = bool(val)
+                else:
+                    # default "float"
+                    val = float(val)
+
+                setattr(column, name, val)
+            except Exception:
+                # keep going even if one assignment fails
+                pass
         return column
 
     return ModelSpec(