sopsim 0.2.0__py3-none-any.whl

sopsim/__init__.py

@@ -0,0 +1,5 @@
+"""SOPSim package."""
+from .core import sopsim
+
+__all__ = ["sopsim"]
+__version__ = "0.1.0"

sopsim/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+
+raise SystemExit(main())

sopsim/artifacts.py

@@ -0,0 +1,79 @@
+"""Utilities for writing local SOPSim outputs."""
+from __future__ import annotations
+
+import json
+import pathlib
+from typing import Any, Dict
+
+import numpy as np
+
+from .run_sopsim import generate_plots
+
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, (np.integer, np.floating)):
+        return value.item()
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    return value
+
+
+def write_metadata(out_dir: pathlib.Path, inputs: Dict[str, Any], FData, extra: Dict[str, Any] | None = None) -> dict:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    metadata = {
+        "inputs": _jsonable(inputs),
+        "FData": _jsonable(FData),
+        "summary": {
+            "FinalTime": float(FData[0]),
+            "RSA": float(FData[1]),
+            "mean_LSA": float(FData[2]),
+        },
+    }
+    if extra:
+        metadata.update(_jsonable(extra))
+
+    (out_dir / "metadata.json").write_text(json.dumps(metadata, indent=2))
+    return metadata
+
+
+def save_simulation_outputs(
+    out_dir: pathlib.Path,
+    inputs: Dict[str, Any],
+    FData,
+    LSA,
+    MeanDin,
+    Notch_time_step,
+    MeanSOPNotch,
+    MeanEPNotch,
+    FinalNotch,
+    ContP,
+    *,
+    generate_figures: bool = True,
+) -> dict:
+    """Persist the standard output bundle for a completed simulation."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if generate_figures:
+        generate_plots(
+            inputs["Nc"],
+            inputs["r"],
+            ContP,
+            MeanDin,
+            Notch_time_step,
+            MeanSOPNotch,
+            MeanEPNotch,
+            FinalNotch,
+            LSA,
+            out_dir,
+        )
+    return write_metadata(
+        out_dir,
+        inputs,
+        FData,
+        extra={
+            "result_files": sorted(path.name for path in out_dir.iterdir() if path.is_file()),
+        },
+    )

sopsim/cli.py

@@ -0,0 +1,157 @@
+"""Command line entry point for SOPSim."""
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import sys
+from typing import Sequence
+
+import uvicorn
+
+from .artifacts import save_simulation_outputs
+from .config import (
+    FILOPODIA_LIFE_TIME_VALIDATION_MESSAGE,
+    FILOPODIA_TYPE_VALIDATION_MESSAGE,
+    FILOPODIA_TYPES,
+    MATLAB_REFERENCE_NC,
+    MATLAB_REFERENCE_VALIDATION_MESSAGE,
+    MIN_FILOPODIA_LIFE_TIME,
+    MIN_NC,
+    NC_VALIDATION_MESSAGE,
+    SimulationInputs,
+    build_simulation_parameters,
+)
+from .core import sopsim
+
+DEFAULT_FILOPODIA_TYPE = SimulationInputs().filopodia_type
+DEFAULT_FILOPODIA_LIFE_TIME = SimulationInputs().filopodia_life_time
+
+
+class SOPSimArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:  # pragma: no cover - exercised through CLI behavior
+        self.print_help(sys.stderr)
+        self.exit(2, f"\nError: {message}\n")
+
+
+def positive_int(value: str, *, minimum: int, label: str) -> int:
+    try:
+        parsed = int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(f"{label} must be an integer >= {minimum}.") from exc
+    if parsed < minimum:
+        raise argparse.ArgumentTypeError(f"{label} must be an integer >= {minimum}.")
+    return parsed
+
+
+def run_simulation(args: argparse.Namespace) -> int:
+    inputs = SimulationInputs(
+        Nc=args.nc,
+        filopodia_type=args.filopodia_type,
+        filopodia_life_time=args.filopodia_life_time,
+        use_mat_files=args.use_mat_files,
+    )
+    params = build_simulation_parameters(inputs)
+    result = sopsim(
+        Nc=inputs.Nc,
+        filopodia_type=inputs.filopodia_type,
+        filopodia_life_time=inputs.filopodia_life_time,
+        use_mat_files=inputs.use_mat_files,
+    )
+    out_dir = pathlib.Path(args.out_dir)
+    metadata = save_simulation_outputs(
+        out_dir,
+        params["inputs"],
+        result["FData"],
+        result["LSA"],
+        result["MeanDin"],
+        result["Notch_time_step"],
+        result["MeanSOPNotch"],
+        result["MeanEPNotch"],
+        result["FinalNotch"],
+        params["ContP"],
+        generate_figures=not args.no_plots,
+    )
+
+    print(json.dumps(metadata["summary"], indent=2))
+    print(f"Saved outputs to {out_dir}")
+    return 0
+
+
+def serve_app(args: argparse.Namespace) -> int:
+    uvicorn.run("sopsim.server:app", host=args.host, port=args.port, reload=args.reload)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = SOPSimArgumentParser(
+        prog="sopsim",
+        description="Run SOPSim locally.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Input summary:\n"
+            f"  Nc: integer >= {MIN_NC}. Required input.\n"
+            f"  filopodia_type: one of {', '.join(FILOPODIA_TYPES)}. Default is {DEFAULT_FILOPODIA_TYPE}.\n"
+            f"  filopodia_life_time: integer >= {MIN_FILOPODIA_LIFE_TIME}. Default is {DEFAULT_FILOPODIA_LIFE_TIME}.\n"
+            f"  use_mat_files: only valid when Nc={MATLAB_REFERENCE_NC}\n"
+            "  r: fixed at 1.0\n\n"
+            "Examples:\n"
+            "  sopsim run --nc 4 --filopodia-type A --filopodia-life-time 10 --out-dir output\n"
+            "  sopsim run --nc 4 --use-mat-files --out-dir output\n"
+            "  sopsim serve" #ALT: sopsim serve --host 127.0.0.1 --port 8000
+        ),
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    run_parser = subparsers.add_parser("run", help="Run one simulation and write local outputs.")
+    run_parser.add_argument(
+        "--nc",
+        type=lambda value: positive_int(value, minimum=MIN_NC, label="Nc"),
+        required=True,
+        help=NC_VALIDATION_MESSAGE,
+    )
+    run_parser.add_argument(
+        "--filopodia-type",
+        choices=FILOPODIA_TYPES,
+        default=DEFAULT_FILOPODIA_TYPE,
+        help=f"{FILOPODIA_TYPE_VALIDATION_MESSAGE} (default: {DEFAULT_FILOPODIA_TYPE})",
+    )
+    run_parser.add_argument(
+        "--filopodia-life-time",
+        type=lambda value: positive_int(value, minimum=1, label="filopodia_life_time"),
+        default=DEFAULT_FILOPODIA_LIFE_TIME,
+        help=f"{FILOPODIA_LIFE_TIME_VALIDATION_MESSAGE} (default: {DEFAULT_FILOPODIA_LIFE_TIME})",
+    )
+    run_parser.add_argument(
+        "--out-dir",
+        type=pathlib.Path,
+        default=pathlib.Path("output"),
+        help="Directory for plots and metadata",
+    )
+    run_parser.add_argument("--no-plots", action="store_true", help="Skip generating figure files")
+    run_parser.add_argument(
+        "--use-mat-files",
+        action="store_true",
+        help=MATLAB_REFERENCE_VALIDATION_MESSAGE,
+    )
+    run_parser.set_defaults(func=run_simulation)
+
+    serve_parser = subparsers.add_parser("serve", help="Start SOPSim as a website, local to your computer.")
+    serve_parser.add_argument("--host", default="127.0.0.1", help="Host interface to bind")
+    serve_parser.add_argument("--port", type=int, default=8000, help="Port to bind")
+    serve_parser.add_argument("--reload", action="store_true", help="Enable uvicorn reload mode")
+    serve_parser.set_defaults(func=serve_app)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    try:
+        args = parser.parse_args(argv)
+        if not hasattr(args, "func"):
+            parser.print_help()
+            return 0
+        return int(args.func(args))
+    except ValueError as exc:
+        parser.error(str(exc))

sopsim/config.py

@@ -0,0 +1,174 @@
+"""Shared simulation configuration helpers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from numbers import Integral
+from typing import Any, Dict
+
+import numpy as np
+
+from .reference_data import load_reference_data
+
+FILOPODIA_PROFILES: Dict[str, Dict[str, Any]] = {
+    "A": {"k_mu": [0.0125, 4, 6], "t_frac": [0.45, 0.45]},
+    "B": {"k_mu": [0.0125, 4, 6], "t_frac": [0.4, 0.65]},
+    "C": {"k_mu": [0.0125, 4, 12], "t_frac": [0.65, 0.65]},
+    "D": {"k_mu": [0.0125, 5, 9], "t_frac": [0.25, 0.8]},
+}
+
+DEFAULT_ALPHA = np.array(
+    [
+        [0.3, 0.65, 0.8],
+        [0.25, 0.6, 0.75],
+        [0.2, 0.75, 0.90],
+    ]
+)
+
+DEFAULT_RADIUS = 1.0
+MATLAB_REFERENCE_NC = 4
+MIN_NC = 1
+MIN_FILOPODIA_LIFE_TIME = 1
+NC_RUNTIME_WARNING_THRESHOLD = 10
+FILOPODIA_TYPES = tuple(FILOPODIA_PROFILES.keys())
+NC_VALIDATION_MESSAGE = f"Number of cells per row (Nc) must be an integer >= {MIN_NC}."
+FILOPODIA_LIFE_TIME_VALIDATION_MESSAGE = f"filopodia_life_time must be an integer >= {MIN_FILOPODIA_LIFE_TIME}."
+FILOPODIA_TYPE_VALIDATION_MESSAGE = f"filopodia_type must be one of {', '.join(FILOPODIA_TYPES)}."
+MATLAB_REFERENCE_VALIDATION_MESSAGE = f"MATLAB reference mode is only supported when Nc={MATLAB_REFERENCE_NC}."
+
+
+@dataclass(frozen=True)
+class SimulationInputs:
+    Nc: int
+    filopodia_type: str = "A"
+    filopodia_life_time: int = 10
+    use_mat_files: bool = False
+
+    def validate(self) -> None:
+        if not isinstance(self.Nc, Integral) or isinstance(self.Nc, bool):
+            raise ValueError(NC_VALIDATION_MESSAGE)
+        if not isinstance(self.filopodia_life_time, Integral) or isinstance(self.filopodia_life_time, bool):
+            raise ValueError(FILOPODIA_LIFE_TIME_VALIDATION_MESSAGE)
+        if self.Nc < MIN_NC:
+            raise ValueError(NC_VALIDATION_MESSAGE)
+        if self.filopodia_life_time < MIN_FILOPODIA_LIFE_TIME:
+            raise ValueError(FILOPODIA_LIFE_TIME_VALIDATION_MESSAGE)
+        if self.filopodia_type not in FILOPODIA_PROFILES:
+            raise ValueError(FILOPODIA_TYPE_VALIDATION_MESSAGE)
+        if self.use_mat_files and self.Nc != MATLAB_REFERENCE_NC:
+            raise ValueError(MATLAB_REFERENCE_VALIDATION_MESSAGE)
+
+
+def build_simulation_parameters(inputs: SimulationInputs) -> Dict[str, Any]:
+    """Build the low-level arrays used by the simulator."""
+    inputs.validate()
+
+    if inputs.Nc >= NC_RUNTIME_WARNING_THRESHOLD:
+        import warnings
+
+        warnings.warn(
+            f"Nc={inputs.Nc} can take many hours to run. Consider a smaller value for testing.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    tf = 3000
+    dt = 1.0
+    t_check = 120
+    MinConvergeTime = 600
+    MinSaveTime = 0
+    FreqSave = 10
+    MaxIt = tf / dt + 1
+    LifeTime = int(inputs.filopodia_life_time)
+
+    TimeP = [tf, dt, t_check, MinConvergeTime, MinSaveTime, FreqSave, MaxIt, LifeTime]
+
+    R_N = 0.1
+    R_D = 0.1
+    mu = 0.002
+    rho = 0.002
+    a = 0.01
+    b = 100
+    h = 9
+    k = 9
+    ModelP = [R_N, R_D, mu, rho, a, b, h, k]
+
+    MinStableValue = 2
+    F_rate = 0.01
+    N_sigma = 0.01
+    D_sigma = 0.01
+    F_sigma = 0.3
+    N_thresh = 1.0
+    CellsAway = 3
+    ContP = [inputs.Nc, MinStableValue, F_rate, DEFAULT_RADIUS, N_sigma, D_sigma, F_sigma, N_thresh, CellsAway]
+
+    N_mu = 1.0
+    D_mu = 1.0
+    F_mu = 2.50
+    a_apical = 0.1
+    a_basal = 0.1
+    FixVals = [N_mu, D_mu, F_mu, a_apical, a_basal]
+
+    fdelta = 2.7e-3
+    fa0 = 10
+    fKbT = 4.1e-3
+    fN = 15
+    fD = 5
+    feta = 20
+    fFt = 20
+    ftau = 2000
+    fK0 = 10
+    fm = 0.1
+    fw = 0.01
+    fk_sigma = 6e-3
+    fNum_filop = inputs.Nc * inputs.Nc * 6
+    fdt = 0.1
+    ftf = LifeTime * 60
+    fselectIndx = 60 / fdt
+    fFs = fKbT * fN / fdelta
+    fP = 60
+
+    LentPar = [
+        fdelta,
+        fa0,
+        fKbT,
+        fN,
+        fD,
+        feta,
+        fFt,
+        ftau,
+        fK0,
+        fm,
+        fw,
+        fk_sigma,
+        fNum_filop,
+        fdt,
+        ftf,
+        fselectIndx,
+        fFs,
+        LifeTime,
+        fP,
+    ]
+
+    selected_profile = FILOPODIA_PROFILES[inputs.filopodia_type]
+    k_mu = selected_profile["k_mu"]
+    Tswitch = np.array(selected_profile["t_frac"]) * ftf
+    reference_data = load_reference_data(inputs.Nc) if inputs.use_mat_files else None
+
+    return {
+        "inputs": {
+            "Nc": inputs.Nc,
+            "r": DEFAULT_RADIUS,
+            "filopodia_type": inputs.filopodia_type,
+            "filopodia_life_time": LifeTime,
+            "use_mat_files": inputs.use_mat_files,
+        },
+        "TimeP": TimeP,
+        "ModelP": ModelP,
+        "ContP": ContP,
+        "FixVals": FixVals,
+        "LentPar": LentPar,
+        "k_mu": k_mu,
+        "alpha": DEFAULT_ALPHA.copy(),
+        "Tswitch": Tswitch,
+        "reference_data": reference_data,
+    }

sopsim/core.py

@@ -0,0 +1,69 @@
+"""Public API for SOPSim."""
+from __future__ import annotations
+
+import warnings
+import threading
+from typing import Any, Dict
+
+from .config import SimulationInputs, build_simulation_parameters
+from .config import NC_RUNTIME_WARNING_THRESHOLD
+from .run_sopsim import run_sopsim
+
+
+def sopsim(
+    Nc: int,
+    filopodia_type: str = "A",
+    filopodia_life_time: int = 10,
+    use_mat_files: bool = False,
+    cancel_event: threading.Event | None = None,
+) -> Dict[str, Any]:
+    """Run the SOPSim simulation and return results.
+
+    Args:
+        Nc: Number of cells per row.
+        filopodia_type: Filopodia profile type (A, B, C, D).
+        filopodia_life_time: Filopodia lifetime in minutes.
+        use_mat_files: Use bundled MATLAB reference inputs for Nc=4.
+
+    Returns:
+        Dictionary with simulation outputs and input parameters.
+    """
+    if Nc >= NC_RUNTIME_WARNING_THRESHOLD:
+        warnings.warn(
+            f"Nc={Nc} can take many hours to run. Consider a smaller value for testing.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    params = build_simulation_parameters(
+        SimulationInputs(
+            Nc=Nc,
+            filopodia_type=filopodia_type,
+            filopodia_life_time=filopodia_life_time,
+            use_mat_files=use_mat_files,
+        )
+    )
+
+    FData, LSA, MeanDin, Notch_time_step, MeanSOPNotch, MeanEPNotch, FinalNotch = run_sopsim(
+        params["LentPar"],
+        params["TimeP"],
+        params["ModelP"],
+        params["ContP"],
+        params["FixVals"],
+        params["k_mu"],
+        params["alpha"],
+        params["Tswitch"],
+        reference_data=params["reference_data"],
+        cancel_event=cancel_event,
+    )
+
+    return {
+        "FData": FData,
+        "LSA": LSA,
+        "MeanDin": MeanDin,
+        "Notch_time_step": Notch_time_step,
+        "MeanSOPNotch": MeanSOPNotch,
+        "MeanEPNotch": MeanEPNotch,
+        "FinalNotch": FinalNotch,
+        "inputs": params["inputs"],
+    }

sopsim/delta_in.py

@@ -0,0 +1,111 @@
+import numpy as np
+import os
+import atexit
+from concurrent.futures import ProcessPoolExecutor
+
+from .filop_vectors import FilopVectors
+
+_DEFAULT_EXECUTOR = None
+
+
+def _get_default_executor():
+    global _DEFAULT_EXECUTOR
+    if _DEFAULT_EXECUTOR is None:
+        max_workers = os.cpu_count() or 1
+        _DEFAULT_EXECUTOR = ProcessPoolExecutor(max_workers=max_workers)
+    return _DEFAULT_EXECUTOR
+
+
+def _shutdown_default_executor():
+    global _DEFAULT_EXECUTOR
+    if _DEFAULT_EXECUTOR is not None:
+        _DEFAULT_EXECUTOR.shutdown(wait=True, cancel_futures=False)
+        _DEFAULT_EXECUTOR = None
+
+
+atexit.register(_shutdown_default_executor)
+
+
+def _process_cell(args):
+    cellp, DirVec, Fbase, FilopDisc, JunctDisc, a_apical, a_basal, Delta = args
+
+    SumOfDeltaJ = 0
+    SumOfDeltaF = 0
+    count = 0
+
+    JList = JunctDisc[cellp]
+    for ijunc in range(len(JList)):
+        SumOfDeltaJ += (a_apical / 2.0) * float(Delta[JList[ijunc] - 1])
+
+    FList = FilopDisc[cellp]
+    for ifilop in range(len(FList)):
+        neighbor = FList[ifilop] - 1
+        for ip in range(0, 6):
+            Vp = DirVec[ip, cellp, :]
+            bp = Fbase[ip, cellp, :]
+
+            Vq_all = np.squeeze(DirVec[:, neighbor, :])
+            bq_all = np.squeeze(Fbase[:, neighbor, :])
+
+            for jq in range(0, 6):
+                Vq = Vq_all[jq, :]
+                bq = bq_all[jq, :]
+
+                A = np.vstack((Vp, -Vq)).T
+                bb = bq.reshape(2, 1) - bp.reshape(2, 1)
+                detA = A[0, 0] * A[1, 1] - A[0, 1] * A[1, 0]
+                if abs(detA) > 1e-10:
+                    T1 = (bb[0] * A[1, 1] - bb[1] * A[0, 1]) / detA
+                    T2 = (A[0, 0] * bb[1] - A[1, 0] * bb[0]) / detA
+                    if (T1 >= 0 and T1 <= 1) and (T2 >= 0 and T2 <= 1):
+                        SumOfDeltaF = SumOfDeltaF + (a_basal / 24) * Delta[neighbor]
+                        count += 1
+                        break
+
+    return SumOfDeltaJ, SumOfDeltaF, count
+
+
+def DeltaIn(Nc, r, F, Ang, CellsAway, a_apical, a_basal, Delta, executor=None):
+    DirVec, Fbase, _, FilopDisc, JunctDisc = FilopVectors(Nc, r, F, Ang, CellsAway)
+
+    args_list = [
+        (cellp, DirVec, Fbase, FilopDisc, JunctDisc, a_apical, a_basal, Delta)
+        for cellp in range(Nc * Nc)
+    ]
+
+    if executor is None:
+        executor = _get_default_executor()
+
+    results = list(executor.map(_process_cell, args_list))
+
+    DinJ = [r[0] for r in results]
+    DinF = [r[1] for r in results]
+    Fcount = [r[2] for r in results]
+
+    return DinJ, DinF, Fcount
+
+
+def KonBar(t, Tswitch, K0, m):
+    t0 = Tswitch[1]
+    if t < t0:
+        Kon = K0
+    else:
+        Kon = K0 * np.exp(-m * (t - t0))
+    return Kon
+
+
+def OneMyosin(t, myo_alpha, f0, P):
+    tloc = np.fmod(t, P)
+    a1 = myo_alpha[0]
+    a2 = myo_alpha[1]
+    a3 = myo_alpha[2]
+
+    if tloc <= (a1 * P):
+        Fm = (f0 / (a1 * P)) * tloc
+    elif (tloc > a1 * P) and (tloc <= a2 * P):
+        Fm = f0
+    elif (tloc > a2 * P) and (tloc <= a3 * P):
+        Fm = ((-f0 / ((a3 - a2) * P)) * (tloc - a2 * P)) + f0
+    elif (tloc > a3 * P) and (tloc <= P):
+        Fm = 0
+    return Fm

sopsim/filop_lent.py

@@ -0,0 +1,69 @@
+import numpy as np
+
+from .delta_in import KonBar, OneMyosin
+
+
+def FilopLent(LentPar, k_mu, alpha, Tswitch, kappa_override=None):
+    delta = LentPar[0]
+    a0 = LentPar[1]
+    KbT = LentPar[2]
+    N = LentPar[3]
+    D = LentPar[4]
+    eta = LentPar[5]
+    Ft = LentPar[6]
+    tau = LentPar[7]
+    K0 = LentPar[8]
+    m = LentPar[9]
+    w = LentPar[10]
+    k_sigma = LentPar[11]
+    Num_filop = LentPar[12]
+    dt = LentPar[13]
+    tf = LentPar[14]
+    selectIndx = LentPar[15]
+    Fs = LentPar[16]
+    P = LentPar[18]
+    t = np.arange(0, tf + 0.1, dt)
+
+    N0 = (Ft * delta) / KbT
+    c0 = (1 - (Ft / Fs)) ** w
+
+    if kappa_override is not None:
+        kappa = np.array(kappa_override, dtype=float)
+        if kappa.size != Num_filop:
+            raise ValueError(f"Reference kappa size {kappa.size} does not match expected {Num_filop}.")
+        kappa = kappa.reshape((Num_filop, 1), order="F")
+    else:
+        rng = np.random.default_rng()
+        kappa = k_sigma * rng.standard_normal(Num_filop).reshape((Num_filop, 1), order="F")
+
+    def Vp(L, Kon):
+        return (Kon * delta * a0 * c0) * (
+            1 - ((Kon * L * N) / ((Kon * L * N) + (D * eta * np.exp(N0 / N))))
+        )
+
+    Lmat = np.zeros((Num_filop, t.shape[0]))
+    for n in range(t.shape[0] - 1):
+        if t[n] <= Tswitch[0]:
+            f0 = Ft * k_mu[0]
+            Fm = OneMyosin(t[n], alpha[0, :], f0, P)
+            Vr = (((Ft + Fm) / tau) + kappa).ravel()
+        elif (t[n] > Tswitch[0]) and (t[n] <= Tswitch[1]):
+            f0 = Ft * k_mu[1]
+            Fm = OneMyosin(t[n], alpha[1, :], f0, P)
+            Vr = (((Ft + Fm) / tau) + kappa).ravel()
+        else:
+            f0 = Ft * k_mu[2]
+            Fm = OneMyosin(t[n], alpha[2, :], f0, P)
+            Vr = (((Ft + Fm) / tau) + kappa).ravel()
+
+        Kon = KonBar(t[n], Tswitch, K0, m)
+        Lnew = (Lmat[:, n] + dt * (Vp(Lmat[:, n], Kon) - Vr))
+        Lnew[Lnew < 0] = 0
+        Lmat[:, n + 1] = Lnew
+
+    Lmat = Lmat / 5
+    selectIndx = int(selectIndx)
+
+    Lsub = Lmat[:, ::selectIndx]
+
+    return Lsub