diff --git a/README.md b/README.md
index bacf43c..328d635 100644
--- a/README.md
+++ b/README.md
@@ -2,35 +2,20 @@
-## Temporary README for `well-mixed-abc` Branch
-
-- use `python3 -m pip install -e .` in the root to install the code
at the moment there is only a very little shared code in the poorly named `homogenous_abc.py` file
-- in the `tests` directory there are three sample models:
- - `test_agentsir.py`
- - `test_agentseir.py`
- - `test_spatialseir.py`
-
-### `test_agentsir.py`
-
-Simulates a single well-mixed community with **_SIR_** infection dynamics.
-
-Use the `--help` option to see the command line parameters. The code will write a .CSV, `sir.csv`, to the script directory (`tests`).
-
-### `test_agentseir.py`
-
-Simulates a single well-mixed community with **_SEIR_** infection dynamics.
-
-Use the `--help` option to see the command line parameters. The code will write a .CSV, `seir.csv`, to the script directory (`tests`).
-
-### `test_spatialseir.py`
-
-Simulates a number of _connected communities_, each well-mixed and with **_SEIR_** infection dynamics.
-
-This model currently loads LGA, population, and connectivity data for 774 admin level 2 LGAs in Nigeria along with population data from 2015. The connectivity weights are from a gravity model.
-
-`load_population()` and `load_network()` are in their own functions now to make it easier to customize for another scenario (e.g., England/Wales).
-
-Use the `--help` option to see the command line parameters. The code will write two .CSV files, `spatial_seir.csv` and `spatial_seir_report.csv`, to the working directory. The former has aggregated S, E, I, and R populations at each timestep. The latter has a column for each community, at each timestep, with the number of infected agents in that community at that timestep.
+## Temporary README for `cleanup-for-merge` Branch
+
+- use `python3 -m pip install -e .` in the root to install the code including the NumPy+Numba and Taichi (GPU) implementations of spatial SEIR.
+- in the `tests` directory there are command line scripts to run the two implementations:
+ - `run_numpyba.py`
+ - `run_taichi.py`
+- in the root directory there is a notebook, `start.ipynb`, which
+ - sets meta parameters
+ - sets disease parameters
+ - sets network parameters
+ - chooses a model implementation
+ - runs the model
+ - plots SEIR trajectories for a node
+ - plots a trajectory of %I vs. %S over time
----
@@ -38,16 +23,16 @@ Use the `--help` option to see the command line parameters. The code will write
### First 30 Days (EOY 2023)
-- firm up team/stakeholders/advisory committee
+- firm up team/stakeholders/advisory committee
- enumerate necessary features for reproducing/supporting previous and in-progress modeling efforts
- - measles (kmccarthy)
+ - measles (kmccarthy)
- malaria (cbever/pselvaraj)
- - end-game/end-stage polio (¿kfrey?)
-- enumerate necessary features for outstanding questions and issues
+ - end-game/end-stage polio
+- enumerate necessary features for outstanding questions and issues
### First 60 Days (January 31, 2024)
-- "paper search" / investigate potential existing solutions
+- "paper search" / investigate potential existing solutions
- capture development requirements
- tools for preparing data (demographics, networks, etc.)
- file formats
@@ -59,10 +44,10 @@ Use the `--help` option to see the command line parameters. The code will write
- community transmission dynamics
- agents
- cohorts
- - \*Sim
- - stochastic compartmental
- - ODEs
- - emulator
+ - \*Sim
+ - stochastic compartmental
+ - ODEs
+ - emulator
- demographics
- urban/rural
- class/caste
@@ -73,16 +58,21 @@ Use the `--help` option to see the command line parameters. The code will write
### First 120 Days (February 29, 2024)
-- technical considerations
- - single laptop
- - single laptop w/Nvidia GPU
- - multicore
- - single machine
- - large machine (cloud)
- - beyond?
- - Numpy
+- technical considerations
+ - single laptop
+ - single laptop w/Nvidia GPU
+ - multicore
+ - single machine
+ - large machine (cloud)
+ - beyond?
+ - Numpy
+ - NumPy + Numba
+ - NumPy + Numba + CUDA
+- → best available implementation for hardware at hand:
- NumPy + Numba
- - NumPy + Numba + CUDA
+ - SSE/AVX2/AVX512
+ - OpenMP
+ - CUDA (Nvidia)/Metal (Apple)
## Problem Space
@@ -126,8 +116,8 @@ Are the individual communities well-mixed or should we also provide for explicit
## Notes
-- "light" : How light is "light"?
-- "agent" : Cohorts? Stochastic compartmental?
+- "light" : How light is "light"? → # agents * state/agent <= available RAM
+- "agent" : Cohorts? Stochastic compartmental? → individual agents
- "spatial" : How good are the individual community models? Good enough for non-spatial questions?
-- dynamic properties (e.g. GPU flu simulation)
+- dynamic properties (e.g. GPU flu simulation) → ✅
- ¿Ace/clorton-based state machines?
diff --git a/outputs/20240613-190301-engwal-1-7300-spatial_seir.npy b/outputs/20240613-190301-engwal-1-7300-spatial_seir.npy
new file mode 100644
index 0000000..ff22f22
Binary files /dev/null and b/outputs/20240613-190301-engwal-1-7300-spatial_seir.npy differ
diff --git a/outputs/20240613-190301-engwal-parameters.json b/outputs/20240613-190301-engwal-parameters.json
new file mode 100644
index 0000000..662edc5
--- /dev/null
+++ b/outputs/20240613-190301-engwal-parameters.json
@@ -0,0 +1 @@
+{"exp_mean": 7.0, "exp_std": 1.0, "inf_mean": 7.0, "inf_std": 1.0, "r_naught": 14.0, "prng_seed": 995315, "ticks": 7300, "nodes": 1, "seed": 20240612, "output": "/workspaces/laser/outputs", "scenario": "engwal", "seasonality_factor": 0.10000000149011612, "seasonality_offset": 182, "beta": 2.0, "a": 1.0, "b": 1.0, "c": 2.0, "k": 500.0, "max_frac": 0.05000000074505806}
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 876b138..f279d8a 100755
--- a/setup.py
+++ b/setup.py
@@ -70,6 +70,7 @@ def read(*names, **kwargs):
"matplotlib",
"pandas",
"taichi",
+ "pytest",
],
extras_require={
# eg:
diff --git a/src/idmlaser/community/homogeneous_abc.py b/src/idmlaser/community/homogeneous_abc.py
deleted file mode 100644
index 077b917..0000000
--- a/src/idmlaser/community/homogeneous_abc.py
+++ /dev/null
@@ -1,33 +0,0 @@
-"""Well-mixed Agent Based Community"""
-
-import numpy as np
-
-
-class HomogeneousABC:
- """Homogeneous Agent Based Community"""
- def __init__(self, count, **kwargs):
- self.count = count
- self.steps = []
- for key, value in kwargs.items():
- setattr(self, key, value)
- return
-
- # dynamically add a property to the class
- def add_property(self, name, dtype=np.uint32, default=0):
- """Add a property to the class"""
- # initialize the property to a NumPy array with of size self.count, dtype, and default value
- setattr(self, name, np.full(self.count, default, dtype=dtype))
- return
-
- # add a processing step to be called at each time step
- def add_step(self, step):
- """Add a processing step to be called at each time step"""
- self.steps.append(step)
- return
-
- # run all processing steps at each time step
- def step(self, timestep: np.uint32):
- """Run all processing steps"""
- for step in self.steps:
- step(self, timestep)
- return
diff --git a/src/idmlaser/models/numpynumba.py b/src/idmlaser/models/numpynumba.py
index c5b1eb2..b02bb57 100644
--- a/src/idmlaser/models/numpynumba.py
+++ b/src/idmlaser/models/numpynumba.py
@@ -5,6 +5,8 @@
from datetime import timezone
from pathlib import Path
from typing import Optional
+from typing import Tuple
+
import numba as nb
import numpy as np
@@ -194,24 +196,23 @@ def step(self, tick: int, pbar: tqdm) -> None:
for phase in self._phases:
phase(self, tick)
- def finalize(self, directory: Optional[Path] = None) -> None:
+ def finalize(self, directory: Optional[Path] = None) -> Tuple[Optional[Path], Path]:
"""Finalize the model."""
directory = directory if directory else self.parameters.output
+ directory.mkdir(parents=True, exist_ok=True)
prefix = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
prefix += f"-{self.parameters.scenario}"
try:
- Path(directory / (prefix + "-parameters.json")).write_text(json.dumps(vars(self.parameters), cls=NumpyJSONEncoder))
- print(f"Wrote parameters to '{directory / (prefix + '-parameters.json')}'.")
+ Path(paramfile:= directory / (prefix + "-parameters.json")).write_text(json.dumps(vars(self.parameters), cls=NumpyJSONEncoder))
+ print(f"Wrote parameters to '{paramfile}'.")
except Exception as e:
print(f"Error writing parameters: {e}")
+ paramfile = None
prefix += f"-{self._demographics.nnodes}-{self.parameters.ticks}-"
- np.save(filename := directory / (prefix + "spatial_seir.npy"), self.report)
- print(f"Wrote SEIR channels, by node, to '{filename}'.")
- # sdf = pl.DataFrame(data=self.cases, schema=[f"node{i}" for i in range(len(self._popcounts))])
- # sdf.write_csv(filename := directory / "spatial_seir_cases.csv")
- # print(f"Wrote spatial cases to '{filename}'.")
+ np.save(npyfile := directory / (prefix + "spatial_seir.npy"), self.report)
+ print(f"Wrote SEIR channels, by node, to '{npyfile}'.")
- return
+ return (paramfile, npyfile)
def run(self, ticks: int) -> None:
"""Run the model for a number of ticks."""
diff --git a/src/idmlaser/models/taichi.py b/src/idmlaser/models/taichi.py
index 1a23921..ab412dc 100644
--- a/src/idmlaser/models/taichi.py
+++ b/src/idmlaser/models/taichi.py
@@ -5,6 +5,7 @@
from datetime import timezone
from pathlib import Path
from typing import Optional
+from typing import Tuple
import numpy as np
import taichi as ti
@@ -150,21 +151,22 @@ def step(self, tick: int, pbar: tqdm) -> None:
return
- def finalize(self, directory: Optional[Path] = None) -> None:
+ def finalize(self, directory: Optional[Path] = None) -> Tuple[Optional[Path], Path]:
"""Finalize the model."""
directory = directory if directory else self.parameters.output
+ directory.mkdir(parents=True, exist_ok=True)
prefix = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
prefix += f"-{self.parameters.scenario}"
try:
- Path(directory / (prefix + "-parameters.json")).write_text(json.dumps(vars(self.parameters), cls=NumpyJSONEncoder))
- print(f"Wrote parameters to '{directory / (prefix + '-parameters.json')}'.")
+ Path(paramfile:= directory / (prefix + "-parameters.json")).write_text(json.dumps(vars(self.parameters), cls=NumpyJSONEncoder))
+ print(f"Wrote parameters to '{paramfile}'.")
except Exception as e:
print(f"Error writing parameters: {e}")
prefix += f"-{self._npatches}-{self.parameters.ticks}-"
- np.save(filename := directory / (prefix + "spatial_seir.npy"), self.report.to_numpy())
- print(f"Wrote SEIR channels, by node, to '{filename}'.")
+ np.save(npyfile := directory / (prefix + "spatial_seir.npy"), self.report.to_numpy())
+ print(f"Wrote SEIR channels, by node, to '{npyfile}'.")
- return
+ return (paramfile, npyfile)
@ti.kernel
diff --git a/src/idmlaser/userid/__init__.py b/src/idmlaser/userid/__init__.py
deleted file mode 100644
index 3335f9e..0000000
--- a/src/idmlaser/userid/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""USERID Population and Community implementations."""
-
-from .community import Community
-from .population import Population
-
-__all__ = ["Population", "Community"]
diff --git a/src/idmlaser/userid/community.py b/src/idmlaser/userid/community.py
deleted file mode 100644
index 0ac9b2e..0000000
--- a/src/idmlaser/userid/community.py
+++ /dev/null
@@ -1,170 +0,0 @@
-"""Implement a community of agents, grouped by type."""
-
-from typing import Union
-
-import numpy as np
-
-_FIRST = 0
-_LAST = 1
-
-
-class Group:
- """A (virtual) group of agents."""
-
- def __init__(self, indices):
- # This is a reference (view) into the Community object's array of indices.
- # So, when we move agents, these values will get updated.
- self.indices = indices
- return
-
- def __len__(self):
- first, last = self.indices[:]
- return last - first + 1 if last >= first else 0
-
-
-# def __add_property__(cls, name, field):
-# """Helper function to add a (virtual) property to a class."""
-
-# def getter(self):
-# first, last = self.indices[:]
-# return field[first : last + 1]
-
-# def setter(self, value):
-# first, last = self.indices[:]
-# field[first : last + 1] = value
-# return
-
-# setattr(cls, name, property(getter, setter))
-# return
-
-
-def __add_property__(obj, name, field):
- """Helper function to add a (virtual) property to an object instance."""
-
- def getter(self):
- first, last = self.indices[:]
- return field[first : last + 1]
-
- def setter(self, value):
- first, last = self.indices[:]
- field[first : last + 1] = value
- return
-
- # https://stackoverflow.com/questions/2954331/dynamically-adding-property-in-python
- # properties have to go on a class, so create a new class for this object, if necessary
- cls = type(obj)
- if not hasattr(cls, "__dynamic_properties__"):
- cls = type(cls.__name__, (cls,), {"__dynamic_properties__": True})
- obj.__class__ = cls
- setattr(cls, name, property(getter, setter))
-
- return
-
-
-class Community:
- """A community of agents."""
-
- def __init__(self) -> None:
- self.groupdefs = []
- self.attrdefs = []
-
- self._count = 0
- self.ngroups = -1
- self.igroups = None
- self.gmap = {}
-
- self.groups = {}
- self.attributes = []
-
- return
-
- # def add_community_property(self, name: str, value: Any) -> None:
- # """Add a property to the class."""
- # setattr(self, name, value)
- # return
-
- def add_agent_group(self, name: str, count: int) -> int:
- """Add a group of agents to the community."""
- index = len(self.groupdefs)
- self.groupdefs.append((name, count))
- return index
-
- def add_agent_property(self, name: str, dtype: np.dtype, default: Union[int, float] = 0) -> None:
- """Add a property to the class."""
- self.attrdefs.append((name, dtype, default))
- return
-
- def __len__(self):
- """Return the number of agents in the community."""
- return self._count
-
- @property
- def count(self):
- """Return the number of agents in the community."""
- return len(self)
-
- def allocate(self):
- """Allocate memory for the agents."""
- self._count = sum(gd[1] for gd in self.groupdefs) # get total population
-
- for name, dtype, default in self.attrdefs:
- array = np.full(self.count, default, dtype=dtype)
- setattr(self, name, array) # e.g. self.age
- self.attributes.append(array)
-
- self.ngroups = len(self.groupdefs)
- self.igroups = np.zeros((self.ngroups, 2), dtype=np.int32)
-
- inext = 0
- for index, (name, count) in enumerate(self.groupdefs):
- self.gmap[name] = index
- setattr(self, f"i{name}", index) # save on dictionary lookups
- self.igroups[index, _FIRST] = inext
- self.igroups[index, _LAST] = inext + count - 1
- group = Group(self.igroups[index]) # [index] is implicitly [index,:]
- self.groups[name] = group
- setattr(self, name, group)
- inext += count # + 1
- for (name, _, _), array in zip(self.attrdefs, self.attributes):
- # add a getter/setter for this each property to the Group instance
- __add_property__(group, name, array)
-
- return
-
- def move(self, source: int, index: int, target: int):
- """Move an agent from one group (index) to another group."""
- if target > source:
- if target == source + 1:
- isource, iswap = self.igroups[source, :]
- isource += index
- if isource != iswap:
- for array in self.attributes:
- array[iswap], array[isource] = array[isource], array[iswap]
- self.igroups[source, _LAST] -= 1
- self.igroups[target, _FIRST] -= 1
- else:
- for src in range(source, target):
- dst = src + 1
- isource, iswap = self.igroups[src, :]
- isource += index
- if isource != iswap:
- for array in self.attributes:
- array[iswap], array[isource] = array[isource], array[iswap]
- self.igroups[src, _LAST] -= 1
- self.igroups[dst, _FIRST] -= 1
- # agents are moved to the beginning of the dst group
- index = 0
- elif target < source:
- for src in range(source, target, -1):
- dst = src - 1
- iswap = self.igroups[src, _FIRST]
- isource = iswap + index
- if isource != iswap:
- for array in self.attributes:
- array[iswap], array[isource] = array[isource], array[iswap]
- self.igroups[src, _FIRST] += 1
- self.igroups[dst, _LAST] += 1
- # agents are moved to the end of the dst group
- index = self.igroups[dst, _LAST] - self.igroups[dst, _FIRST]
-
- return
diff --git a/src/idmlaser/userid/population.py b/src/idmlaser/userid/population.py
deleted file mode 100644
index c1a5226..0000000
--- a/src/idmlaser/userid/population.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""This module contains the Population class, a collection of grouped communities."""
-
-import heapq
-from collections import namedtuple
-from dataclasses import dataclass
-from dataclasses import field
-from typing import Any
-from typing import Dict
-
-from .community import Community
-
-ScheduledEvent = namedtuple("ScheduledEvent", ["func", "nodes", "args", "kwargs"])
-
-
-@dataclass(order=True)
-class ScheduledItem:
- tick: int
- eid: int
- event: ScheduledEvent = field(compare=False)
-
-
-class Population:
- """A collection of grouped communities."""
-
- eid = 0
-
- def __init__(self, num_communities, community_props, agent_groups, agent_props):
- self.num_communities = num_communities
- self._communities = []
- self.community_props = community_props
- self.agent_groups = agent_groups
- self.agent_props = agent_props
- self.queue = []
-
- return
-
- def realize(self, callback):
- """Realize the set communities using the callback to initialize each community in turn."""
- for i in range(self.num_communities):
- community = Community()
- callback(self, community, i)
- self._communities.append(community)
-
- return
-
- def add_population_property(self, name: str, value: Any) -> None:
- """Add a property to the class."""
- setattr(self, name, value)
- return
-
- def allocate_community(self, community: Community, pops: Dict[str, int]) -> None:
- """Allocate memory for a community."""
- # for name in self.community_props:
- # community.add_community_property(name, props[name] if name in props else None)
- for name in self.agent_groups:
- community.add_agent_group(name, pops[name] if name in pops else 0)
- for prop in self.agent_props:
- community.add_agent_property(*prop)
- community.allocate()
- return
-
- @property
- def communities(self):
- """Return the communities."""
- return self._communities
-
- def apply(self, callback, *args, **kwargs):
- """Apply the callback to each community in turn."""
- for index, community in enumerate(self._communities):
- callback(self, community, index, *args, **kwargs)
- return
-
- def add_event(self, event: ScheduledEvent, tick: int):
- """Add an event to each community."""
- heapq.heappush(self.queue, ScheduledItem(tick, self.eid, event))
- self.eid += 1
- return
-
- def do_events(self, tick):
- """Do scheduled events for this tick."""
- while self.queue and (self.queue[0].tick == tick):
- event = heapq.heappop(self.queue).event
- for index, community in enumerate(self._communities):
- if (not event.nodes) or (index in event.nodes):
- event.func(self, community, index, *event.args, **event.kwargs)
- return
diff --git a/start.ipynb b/start.ipynb
new file mode 100644
index 0000000..4cd3854
--- /dev/null
+++ b/start.ipynb
@@ -0,0 +1,369 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Welcome to LASER\n",
+ "\n",
+ "We will start specifying some parameters here. Meta parameters controlling the simulation itself and disease parameters for infection dynamics.\n",
+ "\n",
+ "The `Bag()` class is just a convenience class to make code cleaner. E.g., `params.ticks` rather than `params[\"ticks\"]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pathlib import Path\n",
+ "\n",
+ "import numpy as np\n",
+ "\n",
+ "\n",
+ "# just a holder of values\n",
+ "class Bag:\n",
+ " def __init__(self, *bags):\n",
+ " for bag in bags:\n",
+ " for key, value in bag.__dict__.items():\n",
+ " setattr(self, key, value)\n",
+ "\n",
+ " def __plus__(self, other):\n",
+ " return Bag(self, other)\n",
+ " \n",
+ " def __iadd__(self, other):\n",
+ " for key, value in other.__dict__.items():\n",
+ " setattr(self, key, value)\n",
+ " return self\n",
+ "\n",
+ "metaparams = Bag()\n",
+ "metaparams.ticks = 365 * 20\n",
+ "metaparams.nodes = 1\n",
+ "metaparams.seed = 20240612\n",
+ "metaparams.output = Path.cwd() / \"outputs\"\n",
+ "\n",
+ "parameters = Bag()\n",
+ "parameters.exp_mean = np.float32(7.0)\n",
+ "parameters.exp_std = np.float32(1.0)\n",
+ "parameters.inf_mean = np.float32(7.0)\n",
+ "parameters.inf_std = np.float32(1.0)\n",
+ "parameters.r_naught = np.float32(14.0)\n",
+ "parameters.seasonality_factor = np.float32(0.1)\n",
+ "parameters.seasonality_offset = np.int32(182.5)\n",
+ "\n",
+ "parameters.beta = parameters.r_naught / parameters.inf_mean\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----\n",
+ "\n",
+ "## Scenarios\n",
+ "\n",
+ "Two scenarios are easily available for modeling: England + Wales (1944-1964 demographics) and Nigeria (2015 population).\n",
+ "\n",
+ "The E+W scenario caches just the distances between nodes and builds the node connectivity matrix on the fly from $C(n_i, n_j) = k * \\frac {n_i^a * n_j^b} {d_{i,j}^c}$\n",
+ "\n",
+ "The Nigeria scenario caches a connectivity matrix from Kurt's work which can be modified by a scaling factor and upper limit on daily \"migration\".\n",
+ "\n",
+ "Each `initialize` function returns the maximum number of agents we need to accomodate (for memory allocation purposes), the demographics over time, the initial distribution of agents in the S/E/I/R states, and the network connectivity matrix."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Initial population: 2,462,500\n",
+ "Total births: 1,111,495\n",
+ "Total immigrations: 649,201\n",
+ "Max capacity: 4,223,196\n"
+ ]
+ }
+ ],
+ "source": [
+ "# England and Wales Scenario\n",
+ "metaparams.scenario = \"engwal\"\n",
+ "\n",
+ "# England and Wales network parameters (we derive connectivity from these and distance)\n",
+ "netparams = Bag()\n",
+ "netparams.a = np.float32(1.0) # pop1 power\n",
+ "netparams.b = np.float32(1.0) # pop2 power\n",
+ "netparams.c = np.float32(2.0) # distance power\n",
+ "netparams.k = np.float32(500.0) # scaling factor\n",
+ "netparams.max_frac = np.float32(0.05) # max fraction of population that can migrate\n",
+ "\n",
+ "from tests.scenario_engwal import initialize_engwal\n",
+ "params = Bag(metaparams, parameters, netparams)\n",
+ "max_capacity, demographics, initial, network = initialize_engwal(None, params, params.nodes) # doesn't need a model, yet\n",
+ "\n",
+ "# Nigeria Scenario\n",
+ "# metaparams.scenario = \"nigeria\"\n",
+ "\n",
+ "# Nigeria network parameter(s)\n",
+ "# netparams = Bag()\n",
+ "# netparams.k = np.float32(1.0) # scaling factor\n",
+ "# netparams.max_frac = np.float32(0.05) # max fraction of population that can migrate\n",
+ "\n",
+ "# from tests.scenario_nigeria import initialize_nigeria\n",
+ "# params = Bag(metaparams, parameters, netparams)\n",
+ "# max_capacity, demographics, initial, network = initialize_nigeria(None, params, params.nodes) # doesn't need a model, yet\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----\n",
+ "\n",
+ "## Implementation\n",
+ "\n",
+ "We default to the CPU based implementation (NumPy + Numba). The alternative, if running locally or otherwise capable hardware, is the Taichi/GPU implementation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[Taichi] version 1.7.1, llvm 15.0.4, commit 0f143b2f, linux, python 3.10.13\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[I 06/13/24 18:58:58.599 2411] [shell.py:_shell_pop_print@23] Graphical python shell detected, using wrapped sys.stdout\n",
+ "[W 06/13/24 18:58:58.869 2411] [cuda_driver.cpp:load_lib@36] libcuda.so lib not found.\n",
+ "[W 06/13/24 18:58:58.870 2411] [opengl_api.cpp:initialize_opengl@205] Can not create OpenGL context\n",
+ "[W 06/13/24 18:58:58.871 2411] [misc.py:adaptive_arch_select@758] Arch=[, , , , , , , ] is not supported, falling back to CPU\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[Taichi] Starting on arch=x64\n",
+ "Model parameters: {'exp_mean': 7.0, 'exp_std': 1.0, 'inf_mean': 7.0, 'inf_std': 1.0, 'r_naught': 14.0, 'prng_seed': 995315, 'ticks': 7300, 'nodes': 1, 'seed': 20240612, 'output': PosixPath('/workspaces/laser/outputs'), 'scenario': 'engwal', 'seasonality_factor': 0.1, 'seasonality_offset': 182, 'beta': 2.0, 'a': 1.0, 'b': 1.0, 'c': 2.0, 'k': 500.0, 'max_frac': 0.05}\n",
+ "Initializing model with 1 nodes: (initial population: 2,462,500 maximum capacity: 4,223,196)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from datetime import datetime\n",
+ "\n",
+ "params.prng_seed = datetime.now(tz=None).microsecond\n",
+ "\n",
+ "# CPU based implementation\n",
+ "from idmlaser.models import NumbaSpatialSEIR\n",
+ "model = NumbaSpatialSEIR(params)\n",
+ "\n",
+ "# GPU based implementation with Taichi\n",
+ "# from idmlaser.models import TaichiSpatialSEIR\n",
+ "# model = TaichiSpatialSEIR(parameters)\n",
+ "\n",
+ "model.initialize(max_capacity, demographics, initial, network)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----\n",
+ "\n",
+ "## Running\n",
+ "\n",
+ "We run the model for the fully specified number of ticks. Nothing prevents us from running the model for a shorter period of time, inspecting (and possibly modifying) state, and then continuing on with a subsequent `run()` call."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 7300/7300 [02:24<00:00, 50.38it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "elapsed time: 0:02:24.914150\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model.run(params.ticks)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----\n",
+ "\n",
+ "### Save results (optional)\n",
+ "\n",
+ "The `finalize()` function currently merely writes the parameters used and the results (`model.report`) to disk."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote parameters to '/workspaces/laser/outputs/20240613-190301-engwal-parameters.json'.\n",
+ "Wrote SEIR channels, by node, to '/workspaces/laser/outputs/20240613-190301-engwal-1-7300-spatial_seir.npy'.\n"
+ ]
+ }
+ ],
+ "source": [
+ "paramfile, npyfile = model.finalize()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----\n",
+ "\n",
+ "## SEIR Channels\n",
+ "\n",
+ "Let's plot the SEIR values for a node over the duration of the simulation. For single node simulations without any import pressure, we may have had burnout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "