update to workflow

Author: AlexPatrie

examples/EDITED_combined_fvsolver_data.ipynb

@@ -13,6 +13,60 @@
    ],
    "id": "29a6cffd5df3cb63"
   },
+  {
+   "metadata": {
+    "jupyter": {
+     "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2025-01-31T19:58:13.698322Z",
+     "start_time": "2025-01-31T19:57:44.757366Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from pathlib import Path\n",
+    "import tempfile\n",
+    "import shutil\n",
+    "import os\n",
+    "\n",
+    "from pyvcell.data_model.simulation import SpatialSimulation\n",
+    "from pyvcell.data_model.spatial_model import SpatialModel\n",
+    "\n",
+    "\n",
+    "def prepare_input_dir(solver_input_dir: Path, temp_dir_prefix: str = None) -> Path:\n",
+    "    # prepare input dir\n",
+    "    temp_solver_dir = Path(tempfile.mkdtemp(prefix=temp_dir_prefix or 'pyvcell_test_data_'))\n",
+    "    for file in solver_input_dir.iterdir():\n",
+    "        shutil.copy(file, temp_solver_dir)\n",
+    "\n",
+    "    return temp_solver_dir\n",
+    "\n",
+    "\n",
+    "# define input dir, output_dir and spatial model\n",
+    "solver_input_dir = Path(os.getcwd()) / \"solver_input\"\n",
+    "solver_output_dir = Path(os.getcwd()) / \"test_output\"\n",
+    "model_fp = os.path.join(solver_input_dir, \"all.xml\")\n",
+    "\n",
+    "# define editable spatial model and simulation instances\n",
+    "model = SpatialModel(filepath=model_fp)\n",
+    "simulation = SpatialSimulation(model=model, input_dir_path=solver_input_dir, output_dir_path=solver_output_dir)\n",
+    "\n",
+    "# TODO: replace below with simulation.get_input_files()\n",
+    "temp_solver_dir = prepare_input_dir(solver_input_dir)\n",
+    "functions_file = temp_solver_dir / \"SimID_946368938_0_.functions\"\n",
+    "fv_input_file = temp_solver_dir / \"SimID_946368938_0_.fvinput\"\n",
+    "vcg_file = temp_solver_dir / \"SimID_946368938_0_.vcg\"\n",
+    "\n",
+    "job_id = 0\n",
+    "sim_id = 946368938\n",
+    "result = simulation.run(fv_input_file=fv_input_file, vcg_input_file=vcg_file, solver_output_dir=solver_output_dir, sim_id=sim_id, job_id=job_id)\n",
+    "\n"
+   ],
+   "id": "4dd5c4de89c0402c",
+   "outputs": [],
+   "execution_count": null
+  },
   {
    "metadata": {
     "ExecuteTime": {
@@ -40,13 +94,7 @@
     "\n",
     "# -- move all files from solver_input directory to a temporary directory for solving --\n",
     "\n",
-    "def prepare_input_dir(solver_input_dir: Path, temp_dir_prefix: str = None) -> Path:\n",
-    "    # prepare input dir\n",
-    "    temp_solver_dir = Path(tempfile.mkdtemp(prefix=temp_dir_prefix or 'pyvcell_test_data_'))\n",
-    "    for file in solver_input_dir.iterdir():\n",
-    "        shutil.copy(file, temp_solver_dir)\n",
     "\n",
-    "    return temp_solver_dir\n",
     "\n",
     "\n",
     "def prepare_output_dir(solver_output_dir: Path, functions_file: Path) -> None:\n",

examples/solver_input/all.xml

@@ -28,8 +28,7 @@ typing-extensions = "^4.12.2"
 urllib3 = "^2.3.0"
 requests = "^2.32.3"
 python-dateutil = "^2.9.0.post0"
-ipykernel = "^6.29.5"
-jupyterlab = "^4.3.4"
+notebook = "^7.3.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"

examples/solver_input/all_edited.xml

@@ -0,0 +1,80 @@
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Dict
+
+import matplotlib.pyplot as plt
+import numpy as np
+import zarr
+
+from pyvcell.simdata.mesh import CartesianMesh
+from pyvcell.simdata.postprocessing import PostProcessing
+from pyvcell.simdata.simdata_models import PdeDataSet, DataFunctions
+from pyvcell.simdata.zarr_writer import write_zarr
+from pyvcell.solvers.fvsolver import solve as fvsolve
+
+
+class Result(object):
+    def __init__(self, solver_output_dir: Path, sim_id: int, job_id: int):
+        self.solver_output_dir = solver_output_dir
+        self.zarr_dir = self.solver_output_dir / "zarr"
+        self.sim_id = sim_id
+        self.job_id = job_id
+
+        self.dataset = self.get_dataset()
+        self.metadata = self.get_metadata()
+
+    def get_dataset(self, zarr_dir=None) -> zarr.Array | zarr.Group:
+        return zarr.open(zarr_dir or self.zarr_dir, mode='r')
+
+    def get_metadata(self, dataset=None):
+        ds = dataset or self.dataset
+        return ds.attrs.asdict()['metadata']
+
+    def slice_dataset(self, dataset: zarr.Array | zarr.Group, time_index: int, channel_index: int, z_index: int):
+        return dataset[time_index, channel_index, z_index, :, :]
+
+    def plot_slice(self, dataset: zarr.Array | zarr.Group, time_index: int, channel_index: int, z_index: int):
+        data_slice = self.slice_dataset(dataset, time_index, channel_index, z_index)
+
+        metadata = self.get_metadata(dataset)
+        t = metadata['times'][time_index]
+        channel_label = metadata['channels'][channel_index]['label']
+        channel_domain = metadata['channels'][channel_index]['domain_name']
+        title = f"{channel_label} (in {channel_domain}) at t={t}, slice z={z_index}"
+
+        # Display the slice as an image
+        plt.imshow(data_slice)
+        plt.title(title)
+        return plt.show()
+
+    def get_post_processing(self) -> PostProcessing:
+        post_processing = PostProcessing(postprocessing_hdf5_path=self.solver_output_dir / f"SimID_{self.sim_id}_{self.job_id}_.hdf5")
+        post_processing.read()
+        return post_processing
+
+    def _to_zarr(self) -> None:
+        pde_dataset = self._get_pde_dataset()
+        data_functions = self._get_data_functions()
+        mesh = self._get_mesh()
+        return write_zarr(pde_dataset=pde_dataset, data_functions=data_functions, mesh=mesh, zarr_dir=self.zarr_dir)
+
+    def _get_pde_dataset(self) -> PdeDataSet:
+        pde_dataset = PdeDataSet(base_dir=self.solver_output_dir, log_filename=f"SimID_{self.sim_id}_{self.job_id}_.log")
+        pde_dataset.read()
+        return pde_dataset
+
+    def _get_data_functions(self) -> DataFunctions:
+        data_functions = DataFunctions(function_file=self.solver_output_dir / f"SimID_{self.sim_id}_{self.job_id}_.functions")
+        data_functions.read()
+        return data_functions
+
+    def _get_mesh(self) -> CartesianMesh:
+        mesh = CartesianMesh(mesh_file=self.solver_output_dir / f"SimID_{self.sim_id}_{self.job_id}_.mesh")
+        mesh.read()
+        return mesh
+
+
+sim_id = 946368938
+job_id = 0

poetry.lock

@@ -0,0 +1,78 @@
+import abc
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from uuid import uuid4
+
+import matplotlib.pyplot as plt
+import numpy as np
+import zarr
+
+from pyvcell.data_model.result import Result
+from pyvcell.data_model.spatial_model import SpatialModel
+from pyvcell.simdata.mesh import CartesianMesh
+from pyvcell.simdata.postprocessing import PostProcessing
+from pyvcell.simdata.simdata_models import PdeDataSet, DataFunctions
+from pyvcell.simdata.zarr_writer import write_zarr
+from pyvcell.solvers.fvsolver import solve as fvsolve
+
+
+class Simulation(abc.ABC):
+    @abc.abstractmethod
+    def run_simulation(self):
+        pass
+
+
+class SpatialSimulation(object):
+    def __init__(self, model: SpatialModel, input_dir_path: Path, output_dir_path: Path):
+        self.model = model
+        self.input_dir_path = input_dir_path
+        self.output_dir_path = output_dir_path
+
+    def get_input_files(self) -> tuple:
+        model_path = self.model.filepath or Path("model.xml")
+        sbml_fp = self.model.export(
+            os.path.join(self.input_dir_path, model_path)
+        )
+
+        # TODO: call request here and return input files
+        # return functions_file, fv_input_file, vcg_file
+
+    def run(self, fv_input_file: Path, vcg_input_file: Path, solver_output_dir: Path, sim_id: int, job_id: int) -> Result:
+        # prepare output dir/files
+        # self._prepare_output_dir(solver_output_dir, functions_file)
+        # run simulation
+        try:
+            ret_code = self._run_solver(fv_input_file, vcg_input_file, solver_output_dir)
+            assert ret_code == 0
+
+            return Result(solver_output_dir=solver_output_dir, sim_id=sim_id, job_id=job_id)
+        except AssertionError as e:
+            raise e("The simulation did not finish successfully")
+
+    def _prepare_input_dir(self, solver_input_dir: Path, temp_dir_prefix: str = None) -> Path:
+        # prepare input dir
+        temp_solver_dir = Path(tempfile.mkdtemp(prefix=temp_dir_prefix or 'pyvcell_test_data_'))
+        for file in solver_input_dir.iterdir():
+            shutil.copy(file, temp_solver_dir)
+
+        return temp_solver_dir
+
+    def _prepare_output_dir(self, solver_output_dir: Path, functions_file: Path) -> None:
+        # prepare output dir: clear contents of solver_output_dir
+        for file in solver_output_dir.iterdir():
+            if file.is_file() and not file.name.startswith('.'):
+                file.unlink()
+
+        # copy functions file to solver_output_dir
+        shutil.copy(functions_file, solver_output_dir)
+
+    def _run_solver(self, fv_input_file: Path, vcg_input_file: Path, solver_output_dir: Path) -> int:
+        return fvsolve(input_file=fv_input_file, vcg_file=vcg_input_file, output_dir=solver_output_dir)
+
+
+
+
+
+

pyproject.toml

@@ -0,0 +1,40 @@
+from pathlib import Path
+import os
+import libsbml
+
+
+class SpatialModel(object):
+    """
+    Spatial extension of `libsbml.Model`. All class methods are inherited from `libsbml.Model`: see libsbml documentation for more details.
+    This class is constructed with one of 3 entrypoints: either the filepath to a valid SBMLSpatial model, OR level, version, model_id, OR model_id
+    """
+    def __init__(self, filepath: Path = None, level: int = None, version: int = 3, model_id: str = "model_1"):
+        self.filepath = filepath
+
+        if self.filepath is not None:
+            reader = libsbml.SBMLReader()
+            self.document = reader.readSBML(str(self.filepath))
+            self.model = self.document.getModel()
+        else:
+            self.document = libsbml.SBMLDocument(level, version)
+            self.model = self.document.createModel()
+            self.model.setId(model_id)
+
+    def get(self, attribute: str):
+        """Retrieves a method from the wrapped `libsbml.Model` object if it starts with 'get'."""
+        methods = [attr for attr in dir(self.model) if attr.startswith('get')]
+        method = f'getListOf{attribute[0].upper() + attribute[1:]}'
+        if method in methods:
+            return getattr(self.model, method)
+        else:
+            raise AttributeError(f"Method '{attribute}' not found in libsbml.Model.")
+
+    def export(self, filename: os.PathLike[str]):
+        writer = libsbml.SBMLWriter()
+        return writer.writeSBML(self.document, filename)
+
+    def __getattr__(self, name):
+        """Delegates attribute access to the underlying libsbml.Model instance."""
+        if "export" not in name:
+            return getattr(self.model, name)
+