scripts/simulate_sbml.py

#!/usr/bin/env python3
"""
A minimal standalone example for simulating one SBML model with Tellurium.

Examples
--------
Use a model already stored in SysBio-Traj/Data:
python simulate_sbml.py \
  --model-id BIOMD0000000013 \
  --model-name Poolman2004 \
  --start-time 0 \
  --end-time 0.4 \
  --num-timepoints 512

Use the initial_conditions.json file in the same model directory:
python simulate_sbml.py \
  --model-id BIOMD0000000013 \
  --model-name Poolman2004 \
  --start-time 0 \
  --end-time 0.4 \
  --num-timepoints 512 \
  --use-ic-json \
  --output scripts/BIOMD0000000013_Poolman2004_simulated.csv

Use a custom SBML file directly:
python simulate_sbml.py \
  --xml-file /path/to/model.xml \
  --start-time 0 \
  --end-time 100 \
  --num-timepoints 512 \
  --output /path/to/output.csv
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import numpy as np
import pandas as pd
import tellurium as te


ROOT_DIR = Path(__file__).resolve().parents[1]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Simulate one SBML model.")

    source_group = parser.add_mutually_exclusive_group(required=True)
    source_group.add_argument(
        "--xml-file",
        type=Path,
        help="Path to an SBML XML file.",
    )
    source_group.add_argument(
        "--model-id",
        help="Model ID under SysBio-Traj/Data, for example BIOMD0000000013.",
    )

    parser.add_argument(
        "--model-name",
        help="Model name used to resolve Data/<model_id>/<model_name>.xml.",
    )
    parser.add_argument("--start-time", type=float, required=True, help="Simulation start time.")
    parser.add_argument("--end-time", type=float, required=True, help="Simulation end time.")
    parser.add_argument(
        "--num-timepoints",
        type=int,
        default=512,
        help="Number of sampled time points.",
    )
    parser.add_argument(
        "--output",
        type=Path,
        default=None,
        help="Output CSV path. If omitted, the file is saved in the scripts directory.",
    )
    parser.add_argument(
        "--ic-json",
        type=Path,
        default=None,
        help="Path to a JSON file containing initial conditions.",
    )
    parser.add_argument(
        "--use-ic-json",
        action="store_true",
        help="Use Data/<model_id>/initial_conditions.json.",
    )
    return parser.parse_args()


def resolve_xml_path(args: argparse.Namespace) -> Path:
    if args.xml_file is not None:
        return args.xml_file.resolve()

    if not args.model_name:
        raise ValueError("--model-name is required when --model-id is used.")

    xml_path = ROOT_DIR / "Data" / args.model_id / f"{args.model_name}.xml"
    return xml_path.resolve()


def resolve_output_path(args: argparse.Namespace, xml_path: Path) -> Path:
    if args.output is not None:
        return args.output.resolve()

    if args.model_id and args.model_name:
        filename = f"{args.model_id}_{args.model_name}_simulated.csv"
    else:
        filename = f"{xml_path.stem}_simulated.csv"

    return (ROOT_DIR / "scripts" / filename).resolve()


def resolve_ic_json_path(args: argparse.Namespace) -> Path | None:
    if args.ic_json is not None:
        return args.ic_json.resolve()

    if args.use_ic_json:
        if not args.model_id:
            raise ValueError("--use-ic-json can only be used together with --model-id.")
        return (ROOT_DIR / "Data" / args.model_id / "initial_conditions.json").resolve()

    return None


def load_initial_conditions(ic_json_path: Path | None) -> dict[str, float]:
    if ic_json_path is None:
        return {}

    with ic_json_path.open("r", encoding="utf-8") as f:
        payload = json.load(f)

    if isinstance(payload, dict) and "initial_conditions" in payload:
        payload = payload["initial_conditions"]

    if not isinstance(payload, dict):
        raise ValueError(f"Initial-condition JSON must be a dictionary: {ic_json_path}")

    ic_map: dict[str, float] = {}
    for key, value in payload.items():
        if value is None:
            continue
        ic_map[str(key)] = float(value)
    return ic_map


def set_model_value(rr, name: str, value: float) -> bool:
    candidates = []
    stripped = name.strip()
    bare = stripped[1:-1] if stripped.startswith("[") and stripped.endswith("]") else stripped

    for candidate in (stripped, bare, f"[{bare}]"):
        if candidate not in candidates:
            candidates.append(candidate)

    for candidate in candidates:
        try:
            rr[candidate] = float(value)
            return True
        except Exception:
            continue

    return False


def apply_initial_conditions(rr, ic_map: dict[str, float]) -> None:
    for name, value in ic_map.items():
        ok = set_model_value(rr, name, value)
        if not ok:
            print(f"Warning: cannot set initial condition for '{name}', skipped.")


def normalize_column_name(name: str) -> str:
    text = str(name).strip()
    if text.startswith("[") and text.endswith("]"):
        return text[1:-1]
    return text


def simulate_sbml(
    xml_path: Path,
    output_path: Path,
    start_time: float,
    end_time: float,
    num_timepoints: int,
    ic_json_path: Path | None = None,
) -> Path:
    rr = te.loadSBMLModel(str(xml_path))

    ic_map = load_initial_conditions(ic_json_path)
    if ic_map:
        apply_initial_conditions(rr, ic_map)

    result = rr.simulate(start_time, end_time, num_timepoints)
    columns = [normalize_column_name(name) for name in result.colnames]
    df = pd.DataFrame(np.asarray(result), columns=columns)

    output_path.parent.mkdir(parents=True, exist_ok=True)
    df.to_csv(output_path, index=False)
    return output_path


def main() -> None:
    args = parse_args()
    xml_path = resolve_xml_path(args)
    output_path = resolve_output_path(args, xml_path)
    ic_json_path = resolve_ic_json_path(args)

    if not xml_path.is_file():
        raise FileNotFoundError(f"Cannot find SBML file: {xml_path}")
    if ic_json_path is not None and not ic_json_path.is_file():
        raise FileNotFoundError(f"Cannot find IC JSON file: {ic_json_path}")

    saved_path = simulate_sbml(
        xml_path=xml_path,
        output_path=output_path,
        start_time=args.start_time,
        end_time=args.end_time,
        num_timepoints=args.num_timepoints,
        ic_json_path=ic_json_path,
    )
    print(f"Saved to: {saved_path}")


if __name__ == "__main__":
    main()