Repository: starsimhub/starsim (language: python)

Issue:
Can't use a dist in more than one state anymore  - 'define_states'
 (Context: I am porting tbsim to starsim 2.0 ).... in our Malnutrition Disease Module, as part of the constructor we are using distributions as default values, which used to work fine, but now are failing:

```python
    def __init__(self, pars=None, **kwargs):
        super().__init__(**kwargs)
        self.define_pars(
            beta = 1.0,         # Transmission rate  
            init_prev = 0.001,  # Initial prevalence 
        )
        self.update_pars(pars, **kwargs)

        anthro_path = os.path.join(DATADIR, 'anthropometry.csv')
        self.LMS_data = pd.read_csv(anthro_path).set_index('Sex')

        # Adding Malnutrition states to handle the Individual Properties related to this disease 
        self.define_states(
            # Hooks to the RATIONS trial
            ss.BoolArr('receiving_macro', default=False), # Determines weight trend
            ss.BoolArr('receiving_micro', default=False), # Determines micro trend

            "----->>>>>>>>>>>>>>>>>>>>>> ISSUE TRIGGERED BY DEFAULT VALUES BELOW:
            ss.FloatArr('height_percentile', default=ss.uniform()), # Percentile, stays fixed
            ss.FloatArr('weight_percentile', default=ss.uniform()), # Percentile, increases when receiving micro, then declines?
            ss.FloatArr('micro', default=ss.uniform()), # Continuous? Normal distribution around zero. Z-score, sigmoid thing. Half-life.


        )
        self.dweight = ss.normal(loc=self.dweight_loc, scale=self.dweight_scale)
        return
```

The error is as follows:
```bat
(venvVer2) c:\git\tbsim\scripts\general>python run_malnutrition.py
Starsim 2.0.0 (2024-10-01) — © 2023-2024 by IDM
Initializing sim with 10000 agents
Traceback (most recent call last):
  File "c:\git\tbsim\scripts\general\run_malnutrition.py", line 32, in <module>
    sim_n.run()
  File "c:\git\tbsim\venvVer2\Lib\site-packages\starsim\sim.py", line 298, in run
    if not self.initialized: self.init()
                             ^^^^^^^^^^^
  File "c:\git\tbsim\venvVer2\Lib\site-packages\starsim\sim.py", line 161, in init
    self.init_dists() # Initialize distributions
    ^^^^^^^^^^^^^^^^^
  File "c:\git\tbsim\venvVer2\Lib\site-packages\starsim\sim.py", line 214, in init_dists
    self.dists.init(obj=self, base_seed=self.pars.rand_seed, force=True)
  File "c:\git\tbsim\venvVer2\Lib\site-packages\starsim\distributions.py", line 97, in init
    self.check_seeds()
  File "c:\git\tbsim\venvVer2\Lib\site-packages\starsim\distributions.py", line 107, in check_seeds
    raise DistSeedRepeatError(checked[seed], dist)
starsim.distributions.DistSeedRepeatError: A common seed was found between ss.uniform(people_states_malnutrition.height_percentile_default, pars={'low': 0.0, 'high': 1.0}) and ss.uniform(people_states_malnutrition.height_perc
entile_default_module_micro_default, pars={'low': 0.0, 'high': 1.0}). This is likely caused by incorrect initialization of the parent Dists object.
```

NCD does not run without log=True

Pregnancy runtime error with ASFR due to v2 changes
With dt not 1, the following doesn't work. sim.now is None(?) but also `dur_pregnancy` is incorrect.
```python
            year_ind = sc.findnearest(frd.index, sim.now-self.pars.dur_pregnancy) # TODO: make time-unit-aware
```


Discussion / hints:
this seems like there’s a race condition happening during the setup - the parent Dists object isn’t initialized properly, possibly due to concurrency problems, however this is a very simple script  (not intentionally using parallelization) 
Branch and Disease module:  [ Malnutrition.py __init__ method](https://github.com/starsimhub/tbsim/blob/54d077e3cc9a07ef70558b9febc7c882e5852c29/tbsim/malnutrition.py#L94C83-L94C83)
Found the issue -- two different distributions are being assigned the same `trace` value, because the last 6 digits are the same:
```py
s1 = 'people_states_malnutrition.height_percentile_default_module_micro_default'

s2 = 'people_states_malnutrition.height_percentile_default'

int.from_bytes(s1.encode(), byteorder='big')
Out  [25]: 27799005104623711454959060709994609883093710570832320243914707190666620671010000743368678782368611280387512301456005666920680284384960831028951297485891059307079559274961398900

int.from_bytes(s2.encode(), byteorder='big')
Out  [26]: 74300199819311061043722186592658515386210291499026427434428867777338769916261806379905559986374403707116839290598318545398900
```

Will update to using the hash method for making distribution strings.
Easy workaround seems to be to give the distributions names as follows:
```python
            ss.FloatArr('height_percentile', default=ss.uniform(name='height_percentile')), # Percentile, stays fixed
            ss.FloatArr('weight_percentile', default=ss.uniform(name='weight_percentile')), # Percentile, increases when receiving micro, then declines?
            ss.FloatArr('micro', default=ss.uniform(name='micro')), # Continuous? Normal distribution around zero. Z-score, sigmoid thing. Half-life.
```
Also noticing here that traces get a bit interesting due to distributions having a pointer to the parent module. Perhaps not wrong, but also could be more right?

Example:
```python
'people_states_malnutrition.height_percentile_default' =
ss.uniform(people_states_malnutrition.height_percentile_default, pars={'low': 0.0, 'high': 1.0})
'people_states_malnutrition.height_percentile_default_module_weight_percentile_default' =
ss.uniform(<no trace>, pars={'low': 0.0, 'high': 1.0})
'people_states_malnutrition.height_percentile_default_module_micro_default' =
ss.uniform(<no trace>, pars={'low': 0.0, 'high': 1.0})
```
Distribution traces are weird! Running with TB and malnutrition, the traces appear as follows:
```python
'pars_pregnancy_dur_postpartum' =
ss.lognorm_ex(pars_pregnancy_dur_postpartum, pars={'mean': ss.years(0.5, unit=year, values=26.07142857142857), 'std': ss.years(0.5, unit=year, values=26.07142857142857)})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_female_default' =
ss.bernoulli(pars_pregnancy_dur_postpartum_module_fecund_people_states_female_default, pars={'p': 0.5})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_age_default' =
ss.uniform(pars_pregnancy_dur_postpartum_module_fecund_people_states_age_default, pars={'low': 0, 'high': 100})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_SES_default' =
ss.bernoulli(pars_pregnancy_dur_postpartum_module_fecund_people_states_SES_default, pars={'p': 0.3})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default' =
ss.uniform(pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default, pars={'low': 0.0, 'high': 1.0})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_weight_percentile_default' =
ss.uniform(pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_weight_percentile_default, pars={'low': 0.0, 'high': 1.0})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_micro_default' =
ss.uniform(pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_micro_default, pars={'low': 0.0, 'high': 1.0})
'pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_dweight' =
ss.normal(pars_pregnancy_dur_postpartum_module_fecund_people_states_malnutrition.height_percentile_default_module_dweight, pars={'loc': <function Malnutrition.dweight_loc at 0x16b8685e0>, 'scale': <function Malnutrition.dweight_scale at 0x16b868670>})
```
For whatever reason, these traces do not result in repeated seed errors, whereas running as above with only TB _does_ result in repeats.



Fix patch:
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 3edf66af..a40342eb 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -7,6 +7,12 @@ What's new
 All notable changes to the codebase are documented in this file. Changes that may result in differences in model output, or are required in order to run an old parameter set with the current version, are flagged with the term "Regression information".
 
 
+Version 2.0.1 (2024-10-11)
+---------------------------
+- Adds a new approach to disease transmission called mixing pools. A mixing pool is a "mean field" coupling wherein susceptible agents are exposed to the average infectious agent. The user can create a single mixing pool using the ``MixingPool`` class, or create many pools using ``MixingPools``. Such mixing pools could be used to simulate contact matrices, for example as published by Prem et al.
+- *GitHub info*: PR `697 <https://github.com/starsimhub/starsim/pull/697>`_
+
+
 Version 2.0.0 (2024-10-01)
 --------------------------
 
diff --git a/docs/tutorials.rst b/docs/tutorials.rst
index a02506c2..b121e51d 100644
--- a/docs/tutorials.rst
+++ b/docs/tutorials.rst
@@ -9,8 +9,8 @@ User tutorials
     tutorials/tut_intro.ipynb
     tutorials/tut_buildsim.ipynb
     tutorials/tut_demographics.ipynb
-    tutorials/tut_networks.ipynb
     tutorials/tut_diseases.ipynb
+    tutorials/tut_transmission.ipynb
     tutorials/tut_interventions.ipynb
 
 Developer tutorials
diff --git a/docs/tutorials/tut_diseases.ipynb b/docs/tutorials/tut_diseases.ipynb
index 6b9ec07b..d85cbbf2 100644
--- a/docs/tutorials/tut_diseases.ipynb
+++ b/docs/tutorials/tut_diseases.ipynb
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# T5 - Diseases\n",
+    "# T4 - Diseases\n",
     "\n",
     "Diseases are the cornerstone of almost any Starsim analysis. This is where you add details about what disease you are modeling, including transmissibility, natural history, and mortality outcomes.      \n",
     "\n",
diff --git a/docs/tutorials/tut_networks.ipynb b/docs/tutorials/tut_networks.ipynb
deleted file mode 100644
index 6a75c8eb..00000000
--- a/docs/tutorials/tut_networks.ipynb
+++ /dev/null
@@ -1,211 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# T4 - Networks\n",
-    "\n",
-    "Many infectious diseases transmit when people come into contact with one another. In the basic SIR example that we covered in the first two tutorials, we used a 'random' contact network, which creates random pairings of people. Generally speaking, the structure of network that you use depends on what disease you're modeling. In addition to the 'random' network, Starim contains some basic sexual networks for modeling sexually transmitted infections (STIs) and a 'maternal' network for modeling mother-to-child transmission.  \n",
-    "\n",
-    "In this tutorial, we'll demonstrate a couple of the built-in networks, and give an overview of how you might create your own for your own disease modeling work."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Overview of Starsim's network structure\n",
-    "\n",
-    "Starsim's networks are stored in the `networks.py` file. At the top of this file you'll see the `Network` class, which provides the template for all the other networks. At a high level, all you need to know is that network stores various *parameters* that determine how pairs of people form and dissolve, and a collection of all the *contacts* that exist at a given point in time. Let's look at a simple example of the `random` network:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import starsim as ss\n",
-    "\n",
-    "# Make random network\n",
-    "random = ss.RandomNet()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "The network we just made stores two very important things: the list of contacts (found in `random.contacts`) and the parameters (`random.pars`).  \n",
-    "\n",
-    "If we just make a network on its own like this, it's not very interesting. Like all components of Starsim, it needs to be initialized within a sim before the database of contacts gets populated:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "network = ss.RandomNet()\n",
-    "sir = ss.SIR()\n",
-    "sim = ss.Sim(n_agents=2_000, diseases=sir, networks=network)\n",
-    "sim.init()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "Now `sim.networks.random.contacts` has all the information about which agents (referenced by their UID) are paired with which other agents.\n",
-    "\n",
-    "## Sexual networks\n",
-    "Starsim contains a few basic sexual networks, including an `mf` network for modeling heterosexual partnerships and an `msm` network for men having sex with men. Modeling STIs is a straightforward extension of the SIR example we looked at previously. Here's an example modeling syphilis:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# Create the disease\n",
-    "syph = ss.Syphilis(\n",
-    "    beta = {'mf': [0.25, 0.15]},    # See notes below \n",
-    ")\n",
-    "\n",
-    "# Create a heterosexual network\n",
-    "mf = ss.MFNet(\n",
-    "    duration=1/24,  # Using very short relationships so that we get more transmission \n",
-    "    acts=80,        # Distribution of the number of coital acts/year\n",
-    ")\n",
-    "\n",
-    "pars = dict(start=2000, dur=20, dt=1/12)\n",
-    "sim = ss.Sim(pars=pars, diseases=syph, networks=mf)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "The main difference here is that we've added the line `syph.pars['beta'] = {'mf': [0.25, 0.15]}`. Because STIs are generally more transmissible from males to females than vice versa, we can specify `beta` as a list, and we can also allow it to vary between networks. For instance, if we also had an MSM network here, we could set \n",
-    "```\n",
-    "syph.pars.update(beta = {'mf': [0.25, 0.15], 'msm': [0.4, 0.4]})\n",
-    "```\n",
-    "The sexual network itself is structurally similar to the `random` network that we looked at previously, and can be customized by changing the `pars` dictionary that's used to construct it.\n",
-    " \n",
-    "## Maternal networks\n",
-    "Maternal networks are useful for capturing mother-to-child transmission. If you want to use them, you also need to model pregnancy. Here's an example showing how you would do this for syphilis:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "syph = ss.Syphilis(\n",
-    "    beta = {'mf': [0.25, 0.15], 'maternal': [0.99, 0]}\n",
-    ")\n",
-    "\n",
-    "# Make demographic modules\n",
-    "pregnancy = ss.Pregnancy(fertility_rate=20)\n",
-    "death = ss.Deaths(death_rate=15)\n",
-    "\n",
-    "# Make maternal network\n",
-    "maternal = ss.MaternalNet()\n",
-    "\n",
-    "# Make sim\n",
-    "sim = ss.Sim(pars=pars, diseases=syph, networks=[mf, maternal], demographics=[pregnancy, death])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "## Making your own network\n",
-    "If you want to make your own network, a good place to start is by inheriting from one of the templates in networks.py. For example, if you wanted to make an `mf` network that has more age structure, you could do something like this:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "class age_mf(ss.MFNet):\n",
-    "    def add_pairs(self, people, ti=None):\n",
-    "        # Custom code to select pairs based on age\n",
-    "        return "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "This network would operate exactly like the existing `mf` network, but you could control how new pairs were added.\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.7"
-  },
-  "pycharm": {
-   "stem_cell": {
-    "cell_type": "raw",
-    "metadata": {
-     "collapsed": false
-    },
-    "source": []
-   }
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": true,
-   "sideBar": true,
-   "skip_h1_title": false,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/docs/tutorials/tut_transmission.ipynb b/docs/tutorials/tut_transmission.ipynb
new file mode 100644
index 00000000..a3667fca
--- /dev/null
+++ b/docs/tutorials/tut_transmission.ipynb
@@ -0,0 +1,776 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# T5 - Transmission\n",
+    "\n",
+    "Many infectious diseases transmit when people come into contact with one another. In the basic SIR example that we covered in the first two tutorials, we used a 'random' contact network, which creates random pairings of people. Generally speaking, the structure of network that you use depends on what disease you're modeling.\n",
+    "\n",
+    "Starsim contains two different approaches to disease transmission.\n",
+    "\n",
+    "**Contact network:** Disease transmits on individual person-to-person relationships. These are networks in the sense that each agent (person) can be viewed as a node and each contact is an edge. Networks are undirected in the sense that an edge will allow transmission in both directions, however you can make transmission stronger one way (p1-->p2) than the other (p2-->p1). The framework includes several pre-built contact network algorithms, each of which manages a list of edges that can change on each simulation step. In addition to the 'random' network, the framework include algorithms representing basic sexual networks for modeling sexually transmitted infections (STIs) and a 'maternal' network for modeling mother-to-child transmission.\n",
+    "\n",
+    "**Mixing pools:** Simulate well-mixed transmission from one group of agents to another. Each mixing pool simulates directed transmission from a group of source agents to a group of destination agents. Instead of simulating individual edges like in a contact network, mixing pools first compute the total \"contagion\" that is shed by the source group. This total contagion value is normalized by the number of agents in the source group to arrive at a value that represents a typical infectious source agent. Then, each destination agent is exposed to this typical (average) infectious agent, likely resulting in new infections in the destination group. Multiple mixing pools can be run simultaneously to simulate heterogeneous transmission between various source and destination groups. Mixing pools could be used with age contact matrices like those developed by Prem et al.\n",
+    "\n",
+    "Note that contact networks and mixing pools can be used together in a single simulation.\n",
+    "\n",
+    "In this tutorial, we'll demonstrate a couple of the built-in contact networks, and give an overview of how you might create your own for your own disease modeling work. We'll also demonstrate how to use mixing pools."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overview of Starsim's contact network structure\n",
+    "\n",
+    "Starsim's networks are stored in the `networks.py` file. At the top of this file you'll see the `Network` class, which provides the template for all the other networks. At a high level, all you need to know is that network stores various *parameters* that determine how pairs of people form and dissolve, and a collection of all the *edges* that exist at a given point in time. Let's look at a simple example of the `random` network:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starsim 2.0.1 (2024-10-11) — © 2023-2024 by IDM\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import starsim as ss\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Make random network\n",
+    "random = ss.RandomNet()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "The network we just made stores two very important things: the list of contacts (found in `random.edges`) and the parameters (`random.pars`).  \n",
+    "\n",
+    "If we just make a network on its own like this, it's not very interesting. Like all components of Starsim, it needs to be initialized within a `sim` before the database of contacts gets populated:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initializing sim with 100 agents\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Sim(n=100; 2000—2050; networks=randomnet; diseases=sir)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "net = ss.RandomNet()\n",
+    "sir = ss.SIR()\n",
+    "sim = ss.Sim(n_agents=100, diseases=sir, networks=net) # Decreasing n_agents so we can plot the network below\n",
+    "sim.init()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "We can easily take a look at the list of edges between agents. All networks are stored in `sim.networks`, and individual networks can be found at their class name after conversion to lower case. So for this example, `sim.networks.randomnet.edges` has all the information about which agents (referenced by their UID) are paired with which other agents as well as a per-edge transmission multiplier called `beta` and a per-edge duration, `dur`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "randomnet(\"randomnet\", p1, p2, beta, dur)\n",
+       "     p1  p2  beta  dur\n",
+       "0     0  95   1.0  0.0\n",
+       "1     0  43   1.0  0.0\n",
+       "2     0  50   1.0  0.0\n",
+       "3     0  35   1.0  0.0\n",
+       "4     0  18   1.0  0.0\n",
+       "..   ..  ..   ...  ...\n",
+       "495  99  50   1.0  0.0\n",
+       "496  99  51   1.0  0.0\n",
+       "497  99  95   1.0  0.0\n",
+       "498  99  82   1.0  0.0\n",
+       "499  99  98   1.0  0.0\n",
+       "\n",
+       "[500 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim.networks.randomnet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Networks provide some basic functionality, for example to identify contacts. Additionally, the edge list can be quickly converted to a Pandas data frame for further analysis and manipulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The following agents were identified as contacts of agent 0: [18 35 37 43 47 50 54 72 95]\n",
+      "\n",
+      "Edges involving UID 0 extracted from the edge list data frame:\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>p1</th>\n",
+       "      <th>p2</th>\n",
+       "      <th>beta</th>\n",
+       "      <th>dur</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>95</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>43</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0</td>\n",
+       "      <td>50</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>35</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0</td>\n",
+       "      <td>18</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>175</th>\n",
+       "      <td>35</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>186</th>\n",
+       "      <td>37</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>238</th>\n",
+       "      <td>47</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>272</th>\n",
+       "      <td>54</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>363</th>\n",
+       "      <td>72</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     p1  p2  beta  dur\n",
+       "0     0  95   1.0  0.0\n",
+       "1     0  43   1.0  0.0\n",
+       "2     0  50   1.0  0.0\n",
+       "3     0  35   1.0  0.0\n",
+       "4     0  18   1.0  0.0\n",
+       "175  35   0   1.0  0.0\n",
+       "186  37   0   1.0  0.0\n",
+       "238  47   0   1.0  0.0\n",
+       "272  54   0   1.0  0.0\n",
+       "363  72   0   1.0  0.0"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "net = sim.networks.randomnet\n",
+    "\n",
+    "# Use the \"find_contacts\" function to find all contacts of agent with uid 0\n",
+    "contacts_of_agent_0 = net.find_contacts([0])\n",
+    "print('The following agents were identified as contacts of agent 0:', contacts_of_agent_0)\n",
+    "\n",
+    "# Convert to a pandas DataFrame and manually find all edges involving agent with uid 0\n",
+    "df = net.to_df()\n",
+    "uid0_edges = df.loc[(df['p1']==0) | (df['p2']==0)]\n",
+    "print('\\nEdges involving UID 0 extracted from the edge list data frame:')\n",
+    "display(uid0_edges)\n",
+    "\n",
+    "import networkx as nx\n",
+    "G = net.to_graph()\n",
+    "nx.draw(G, with_labels=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Sexual networks\n",
+    "Starsim contains a few basic sexual networks, including an `mf` network for modeling heterosexual partnerships and an `msm` network for men having sex with men. Modeling STIs is a straightforward extension of the SIR example we looked at previously. Here's an example modeling syphilis:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# Create the disease\n",
+    "syph = ss.Syphilis(\n",
+    "    beta = {'mf': [0.25, 0.15]},    # See notes below \n",
+    ")\n",
+    "\n",
+    "# Create a heterosexual network\n",
+    "mf = ss.MFNet(\n",
+    "    duration=1/24,  # Using very short relationships so that we get more transmission \n",
+    "    acts=80,        # Distribution of the number of coital acts/year\n",
+    ")\n",
+    "\n",
+    "pars = dict(start=2000, dur=20, dt=1/12)\n",
+    "sim = ss.Sim(pars=pars, diseases=syph, networks=mf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "The main difference here is that we've added the line `syph.pars['beta'] = {'mf': [0.25, 0.15]}`. Because STIs are generally more transmissible from males to females than vice versa, we can specify `beta` as a list, and we can also allow it to vary between networks. For instance, if we also had an MSM network here, we could set \n",
+    "```\n",
+    "syph.pars.update(beta = {'mf': [0.25, 0.15], 'msm': [0.4, 0.4]})\n",
+    "```\n",
+    "The sexual network itself is structurally similar to the `random` network that we looked at previously, and can be customized by changing the `pars` dictionary that's used to construct it.\n",
+    " \n",
+    "## Maternal networks\n",
+    "Maternal networks are useful for capturing mother-to-child transmission. If you want to use them, you also need to model pregnancy. As new agents are born via pregnancy, edges are automatically added between mother and prenatal child in the maternal network. Here's an example showing how you would do this for syphilis:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "syph = ss.Syphilis(\n",
+    "    beta = {'mf': [0.25, 0.15], 'maternal': [0.99, 0]}\n",
+    ")\n",
+    "\n",
+    "# Make demographic modules\n",
+    "pregnancy = ss.Pregnancy(fertility_rate=20)\n",
+    "death = ss.Deaths(death_rate=15)\n",
+    "\n",
+    "# Make maternal network\n",
+    "maternal = ss.MaternalNet()\n",
+    "\n",
+    "# Make sim\n",
+    "sim = ss.Sim(pars=pars, diseases=syph, networks=[mf, maternal], demographics=[pregnancy, death])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "## Making your own contact network\n",
+    "If you want to make your own network, a good place to start is by inheriting from one of the templates in networks.py. For example, if you wanted to make an `mf` network that has more age structure, you could do something like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "class age_mf(ss.MFNet):\n",
+    "    def add_pairs(self, people, ti=None):\n",
+    "        # Custom code to select pairs based on age\n",
+    "        return "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "This network would operate exactly like the existing `mf` network, but you could control how new pairs were added.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mixing Pools"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Mixing pools are currently implemented as `Interventions` within the Starsim Framework. You will find the `MixingPool` and `MixingPools` classes in `interventions.py`.\n",
+    "\n",
+    "To begin, let's compare a simple SIR model configured with transmission using a single Mixing Pool to a similar model using a contact network. Mixing pools are not the same as contact networks, so the results are not expected to be identical."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Elapsed time: 1.29 s\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Transmission using a mixing pool\n",
+    "mp = ss.MixingPool(beta=ss.beta(0.1), contacts=ss.poisson(lam=3)) # A single mixing pool\n",
+    "sir = ss.SIR() # Beta doesn't matter, that's just for networks\n",
+    "sim1 = ss.Sim(diseases=sir, interventions=mp, verbose=0, label='Mixing Pool')\n",
+    "\n",
+    "# Transmission using a network\n",
+    "net = ss.RandomNet(n_contacts=ss.poisson(lam=3))\n",
+    "sir = ss.SIR(beta=ss.beta(0.1))\n",
+    "sim2 = ss.Sim(diseases=sir, networks=net, verbose=0, label='Contact Network')\n",
+    "\n",
+    "msim = ss.MultiSim([sim1, sim2]).run()\n",
+    "msim.plot();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Each MixingPool has several configuration parameters, including `src` and `dst`. The value of these parameters can either be an array of uids, like `ss.uids([0,1,2])` or a callable function that takes `sim` as an argument and returns an array of uids (or a BoolArr) like `lambda sim: sim.people.age<10`. One helper class we have created is called `AgeGroup`, which takes `low` and `high` ages as parameters. This class has some performance advantages when using multiple pools via `MixingPools` through caching.\n",
+    "\n",
+    "While mixing pools do not represent individual agent-to-agent connections, each agent does have an \"effective\" number of contacts, typically drawn from a Poisson distribution. Individuals retain their number of contacts within each pool for the duration of the simulation. Effective contacts are used on the acquisition sides. On the transmission side, the \"average\" infection level, called `trans`, against which susceptible agents are challenged is computed as:\n",
+    "```python\n",
+    "trans = np.mean(disease.infectious[self.src_uids] * disease.rel_trans[self.src_uids])\n",
+    "```\n",
+    "And on the acquisition side, each susceptible agent can be thought of as connected to `eff_contacts` average infectious agents, computed as:\n",
+    "```python\n",
+    "acq = self.eff_contacts[self.dst_uids] * disease.susceptible[self.dst_uids] * disease.rel_sus[self.dst_uids]\n",
+    "```\n",
+    "Ultimately, the acquisition probability for each susceptible agent in `dst_uids` is computed as\n",
+    "```python\n",
+    "p = self.pars.beta * trans * acq\n",
+    "```\n",
+    "\n",
+    "You can see the `beta` parameter here, which is another pool parameter and should use `ss.beta()` to automatically adjust for time units. Mixing pools do not currently use the `beta` parameters configured in individual disease modules."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initializing sim with 10000 agents\n",
+      "  Running 2000.0 ( 0/51) (0.00 s)  ———————————————————— 2%\n",
+      "  Running 2010.0 (10/51) (0.04 s)  ••••———————————————— 22%\n",
+      "  Running 2020.0 (20/51) (0.07 s)  ••••••••———————————— 41%\n",
+      "  Running 2030.0 (30/51) (0.10 s)  ••••••••••••———————— 61%\n",
+      "  Running 2040.0 (40/51) (0.13 s)  ••••••••••••••••———— 80%\n",
+      "  Running 2050.0 (50/51) (0.16 s)  •••••••••••••••••••• 100%\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 933.333x700 with 16 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mp = ss.MixingPool(\n",
+    "    diseases = 'sir', # Use this pool only for SIR, not other diseases (HIV in this example)\n",
+    "    src = lambda sim: sim.people.age < 15, # Infection sources will be agents under age 15\n",
+    "    dst = ss.AgeGroup(low=15, high=None), # Here demonstrating the AgeGroup class, identical to lambda sim: sim.people.age >= 15\n",
+    "    contacts = ss.poisson(lam=2), # Contacts will be poisson distributed with a mean of 2\n",
+    "    beta = ss.beta(0.2), # And we set beta to 0.2, automatically adjusting for time units via the ss.beta wrapper\n",
+    ")\n",
+    "sim = ss.Sim(diseases=['sir', 'hiv'], interventions=mp) # Two diseases, only \"sir\" will have transmission\n",
+    "sim.run()\n",
+    "sim.plot();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`MixingPools` (plural) allows you to configure multiple individual `MixingPool` pools. This first example shows how to do age mixing. Like `MixingPool`, `MixingPools` also takes `src` and `dst`, however each of these parameters must be a dictionary with key specifying the name of each group and value as in the singlular mixing pool proving the uids by a callable function or list of uids."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The first axis (rows) of the contact matrix is the SOURCE group\n",
+      "The second axis (columns) of the contact matrix is the DESTINATION group\n",
+      "^^^ The default age distribution is uniform, so the 75+ group contains many more people than the other age groups, explaining the larger number of new infections.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lows = np.arange(0, 80, 5)\n",
+    "#groups = {f'{low}-{high}': ss.AgeGroup(low=low, high=low+5) for low in lows}\n",
+    "groups = ss.ndict([ss.AgeGroup(low=low, high=low+5) for low in lows[:-1]])\n",
+    "groups.append(ss.AgeGroup(low=lows[-1], high=None)) # 80+\n",
+    "#groups[-1].high = None # Make the final group 80+ instead of 80=85\n",
+    "n_groups = len(groups)\n",
+    "\n",
+    "# Let's create a random contact matrix. If using contact matrices from Prem et al., put data here.\n",
+    "cm = np.random.random((n_groups, n_groups)) + 3*np.diag(np.random.rand(n_groups))\n",
+    "\n",
+    "print('The first axis (rows) of the contact matrix is the SOURCE group')\n",
+    "print('The second axis (columns) of the contact matrix is the DESTINATION group')\n",
+    "plt.imshow(cm)\n",
+    "\n",
+    "mps = ss.MixingPools(\n",
+    "    contact_matrix = cm,\n",
+    "    beta = ss.beta(0.2),\n",
+    "    src = groups,\n",
+    "    dst = groups,\n",
+    ")\n",
+    "\n",
+    "# Track new infections by age using an Analyzer, you'll learn about these in a subsequent tutorial\n",
+    "class New_Infections_By_Age(ss.Analyzer):\n",
+    "    def __init__(self, bins, **kwargs):\n",
+    "        super().__init__(**kwargs)\n",
+    "        self.bins = bins\n",
+    "\n",
+    "    def init_post(self):\n",
+    "        super().init_post()\n",
+    "        self.new_cases = np.zeros((self.npts, len(self.bins)-1))\n",
+    "\n",
+    "    def step(self):\n",
+    "        new_inf = self.sim.diseases.sir.ti_infected == self.ti\n",
+    "        if not new_inf.any(): return\n",
+    "        self.new_cases[self.ti, :] = np.histogram(self.sim.people.age[new_inf], bins=self.bins)[0]\n",
+    "\n",
+    "    def plot(self):\n",
+    "        fig, ax = plt.subplots()\n",
+    "        ax.set_prop_cycle('color', plt.cm.nipy_spectral(np.linspace(0, 1, len(self.bins))))\n",
+    "\n",
+    "        for i, (b1, b2) in enumerate(zip(self.bins[:-1], self.bins[1:])):\n",
+    "            ax.plot(self.sim.timevec, self.new_cases[:,i], label=f'Age {b1}-{b2}')\n",
+    "        ax.legend(); ax.set_xlabel('Year'); ax.set_ylabel('New Infections')\n",
+    "\n",
+    "az = New_Infections_By_Age(np.concatenate([lows, [1000]]))\n",
+    "\n",
+    "sir = ss.SIR()\n",
+    "sim = ss.Sim(diseases=sir, interventions=mps, analyzers=az, dur=5, dt=1/4, n_agents=2000, verbose=0)\n",
+    "sim.run()\n",
+    "sim.analyzers[0].plot()\n",
+    "print('^^^ The default age distribution is uniform, so the 75+ group contains many more people than the other age groups, explaining the larger number of new infections.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Mixing pools work well with properties other than age. Here's an example that mixes by socio-economic status (SES)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Infections are seeded into the HIGH group at the beginning of the\n",
+      "simulation, explaining the spike in new cases at that time. HIGH SES can only\n",
+      "infect MID SES, so the MID (orange) wave follows. LOW SES can only become\n",
+      "infected by MID SES in this example, so the blue wave follows. This example\n",
+      "intentionally demonstrates the directional nature of mixing pools and includes\n",
+      "strong mixing within groups and bottlenecks between groups to make the point.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from enum import IntEnum\n",
+    "class SES(IntEnum):\n",
+    "    LOW = 0\n",
+    "    MID = 1\n",
+    "    HIGH = 2\n",
+    "\n",
+    "# Create 5,000 people adding 50% LOW, 30% MID, and 20% HIGH SES\n",
+    "ses = ss.FloatArr('ses', default=ss.choice(a=[SES.LOW, SES.MID, SES.HIGH], p=[0.5, 0.3, 0.2]))\n",
+    "ppl = ss.People(n_agents=5_000, extra_states=ses)\n",
+    "\n",
+    "# Create the mixing pools, note that the contact matrix need not be symmetric\n",
+    "mps = ss.MixingPools(\n",
+    "    src = {s.name: lambda sim, s=s: ss.uids(sim.people.ses == s) for s in [SES.LOW, SES.MID, SES.HIGH]},\n",
+    "    dst = {s.name: lambda sim, s=s: ss.uids(sim.people.ses == s) for s in [SES.LOW, SES.MID]}, # People in the HIGH group have not route to acquire new infections, for demonstration purposes here\n",
+    "\n",
+    "    # src on rows (1st dimension), dst on cols (2nd dimension)\n",
+    "    contact_matrix = np.array([\n",
+    "        [2.50, 0.00], # LOW->LOW,  LOW->MID\n",
+    "        [0.05, 1.75], # MID->LOW,  MID->MID\n",
+    "        [0.00, 0.15], # HIGH->LOW, HIGH->MID\n",
+    "    ]),\n",
+    "\n",
+    "    beta = ss.beta(0.2),\n",
+    ")\n",
+    "\n",
+    "# Create an analyzer to track results by SES group\n",
+    "class New_Infections_By_SES(ss.Analyzer):\n",
+    "    def init_results(self):\n",
+    "        self.new_cases = np.zeros((self.npts, len(SES)))\n",
+    "\n",
+    "    def step(self):\n",
+    "        new_inf = self.sim.diseases.sir.ti_infected == self.ti\n",
+    "        if not new_inf.any():\n",
+    "            return\n",
+    "\n",
+    "        for ses in SES:\n",
+    "            self.new_cases[self.ti, ses] = np.count_nonzero(new_inf & (self.sim.people.ses==ses))\n",
+    "\n",
+    "az = New_Infections_By_SES()\n",
+    "\n",
+    "def seeding(self, sim, uids):\n",
+    "    p = np.zeros(len(uids))\n",
+    "    high_ses = ss.uids(sim.people.ses == SES.HIGH)\n",
+    "    p[high_ses] = 0.1 # Seed infections into 10% of SES HIGH\n",
+    "    return p\n",
+    "sir = ss.SIR(init_prev = ss.bernoulli(p=seeding)) # The probability of being selected as a seed is determined on a per-agent basis by the above 'seeding' function\n",
+    "\n",
+    "sim = ss.Sim(people=ppl, diseases=sir, interventions=mps, analyzers=az, dt=1/12, dur=35, verbose=0)\n",
+    "sim.run()\n",
+    "\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "new_cases = sim.analyzers[0].new_cases\n",
+    "for ses in [SES.LOW, SES.MID, SES.HIGH]:\n",
+    "    ax.plot(sim.results.timevec, new_cases[:,ses], label=ses.name)\n",
+    "ax.legend(); ax.set_xlabel('Year'); ax.set_ylabel('New Infections');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the above figure, infections are seeded into the HIGH group at the beginning of the simulation, explaining the spike in new cases at that time. HIGH SES can only infect MID SES, so the MID (orange) wave follows. LOW SES can only become infected by MID SES in this example, so the blue wave follows. This example intentionally demonstrates the directional nature of mixing pools and includes strong mixing within groups and bottlenecks between groups to make the point."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "IDM",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/starsim/demographics.py b/starsim/demographics.py
index db0357d2..5ffc5faa 100644
--- a/starsim/demographics.py
+++ b/starsim/demographics.py
@@ -306,7 +306,7 @@ def make_fertility_prob_fn(self, sim, uids):
         if sc.isnumber(frd):
             fertility_rate[uids] = self.fertility_rate_data
         else:
-            year_ind = sc.findnearest(frd.index, sim.now-self.pars.dur_pregnancy) # TODO: make time-unit-aware
+            year_ind = sc.findnearest(frd.index, self.now-self.pars.dur_pregnancy.to('year')) # TODO: make time-unit-aware
             nearest_year = frd.index[year_ind]
 
             # Assign agents to age bins
@@ -333,7 +333,7 @@ def make_fertility_prob_fn(self, sim, uids):
 
         # Scale from rate to probability
         invalid_age = (age < self.pars.min_age) | (age > self.pars.max_age)
-        fertility_prob = fertility_rate * (self.pars.units * self.pars.rel_fertility * sim.pars.dt)
+        fertility_prob = fertility_rate * (self.pars.units * self.pars.rel_fertility * self.dt)
         fertility_prob[(~self.fecund).uids] = 0 # Currently infecund women cannot become pregnant
         fertility_prob[uids[invalid_age]] = 0 # Women too young or old cannot become pregnant
         fertility_prob = np.clip(fertility_prob[uids], a_min=0, a_max=1)
diff --git a/starsim/disease.py b/starsim/disease.py
index 378aaeba..cc9f4def 100644
--- a/starsim/disease.py
+++ b/starsim/disease.py
@@ -152,7 +152,7 @@ class Infection(Disease):
     operate on to capture co-infection
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, pars=None, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.define_states(
             ss.State('susceptible', default=True, label='Susceptible'),
@@ -162,6 +162,11 @@ def __init__(self, *args, **kwargs):
             ss.FloatArr('ti_infected', label='Time of infection' ),
         )
 
+        self.define_pars(
+            init_prev = None, # Replace None with a ss.bernoulli to seed infections
+        )
+        self.update_pars(pars, **kwargs)
+
         # Define random number generator for determining transmission
         self.trans_rng = ss.multi_random('source', 'target')
         return
diff --git a/starsim/diseases/ncd.py b/starsim/diseases/ncd.py
index d55fe67e..841eda99 100644
--- a/starsim/diseases/ncd.py
+++ b/starsim/diseases/ncd.py
@@ -55,7 +55,8 @@ def step_state(self):
         ti = self.ti
         deaths = (self.ti_dead == ti).uids
         self.sim.people.request_death(deaths)
-        self.log.add_data(deaths, died=True)
+        if self.pars.log:
+            self.log.add_data(deaths, died=True)
         self.results.new_deaths[ti] = len(deaths) # Log deaths attributable to this module
         return
 
diff --git a/starsim/distributions.py b/starsim/distributions.py
index 42bb243f..79de004e 100644
--- a/starsim/distributions.py
+++ b/starsim/distributions.py
@@ -11,7 +11,7 @@
 __all__ = ['link_dists', 'make_dist', 'dist_list', 'Dists', 'Dist']
 
 
-def str2int(string, modulo=1_000_000):
+def str2int(string, modulo=None):
     """
     Convert a string to an int
 
@@ -21,7 +21,10 @@ def str2int(string, modulo=1_000_000):
     """
     integer = int.from_bytes(string.encode(), byteorder='big')
     # integer = sc.sha(string, asint=True) # Hash the string to an integer
-    out = integer % modulo # Don't need all of it, this is more user-friendly
+    if modulo is None:
+        return integer
+
+    out = integer % modulo # This is more user-friendly
     return out
 
 
@@ -85,7 +88,10 @@ def init(self, obj=None, base_seed=None, sim=None, force=False):
             raise ValueError(errormsg)
 
         # Do not look for distributions in the people states, since they shadow the "real" states
-        skip = id(sim.people._states) if sim is not None else None
+        skip = dict(
+            ids=id(sim.people._states) if sim is not None else None,
+            keys='module',
+        )
 
         # Find and initialize the distributions
         self.dists = sc.search(obj, type=Dist, skip=skip, flatten=True)
diff --git a/starsim/interventions.py b/starsim/interventions.py
index 0fae1f8b..c016d972 100644
--- a/starsim/interventions.py
+++ b/starsim/interventions.py
@@ -464,4 +464,157 @@ class campaign_vx(BaseVaccination, CampaignDelivery):
     Campaign vaccination - an instance of base vaccination combined with campaign delivery.
     See base classes for a description of input arguments.
     """
-    pass
\ No newline at end of file
+    pass
+
+
+__all__ += ['AgeGroup', 'MixingPools', 'MixingPool']
+class AgeGroup():
+    # A simple age-based filter that returns uids of agents that match the criteria
+    def __init__(self, low, high, do_cache=True):
+        self.low = low
+        self.high = high
+
+        self.do_cache = do_cache
+        self.uids = None # Cached
+        self.ti_cache = -1
+
+        self.name = repr(self)
+        return
+
+    def __call__(self, sim):
+        if (not self.do_cache) or (self.ti_cache != sim.ti):
+            in_group = sim.people.age >= self.low
+            if self.high is not None:
+                in_group = in_group & (sim.people.age < self.high)
+            self.uids = ss.uids(in_group)
+            self.ti_cache = sim.ti
+        return self.uids
+
+    def __repr__(self):
+        return f'age {self.low}-{self.high}'
+
+class MixingPools(Intervention):
+    def __init__(self, pars=None, **kwargs):
+        super().__init__(**kwargs)
+
+        self.define_pars(
+            diseases = None,
+            beta = ss.beta(0.1),
+            contact_matrix = np.array([[2.4, 0.49], [0.91, 0.16]]),
+            src = {'0-15': AgeGroup(0,15), '15+': AgeGroup(15,None)}, # Alternatively, values could be a list of UIDs
+            dst = {'0-15': AgeGroup(0,15), '15+': AgeGroup(15,None)},
+        )
+        self.update_pars(pars, **kwargs)
+        self.validate_pars()
+
+        return
+
+    def init_pre(self, sim):
+        super().init_pre(sim)
+
+        for i, (sk, s) in enumerate(self.pars.src.items()):
+            for j, (dk, d) in enumerate(self.pars.dst.items()):
+                contacts = ss.poisson(lam=self.pars.contact_matrix[i,j])
+                name = f'pool:{sk}-->{dk}'
+                mp = MixingPool(diseases=self.pars.diseases, beta=self.pars.beta, contacts=contacts, src=s, dst=d, name=name)
+                mp.init_pre(sim) # Initialize the pool
+                sim.interventions.append(mp)
+        return
+
+    def validate_pars(self):
+        cm = self.pars.contact_matrix
+
+        if not isinstance(self.pars.src, dict):
+            raise Exception(f'src must be a provided as a dictionary, not {type(self.pars.src)}')
+
+        if not isinstance(self.pars.dst, dict):
+            raise Exception(f'dst must be a provided as a dictionary, not {type(self.pars.src)}')
+
+        if cm.shape[0] != len(self.pars.src):
+            raise Exception('The number of source groups must match the number of rows in the mixing matrix.')
+        if cm.shape[1] != len(self.pars.dst):
+            raise Exception('The number of destination groups must match the number of columns in the mixing matrix.')
+        return
+
+class MixingPool(Intervention):
+    def __init__(self, pars=None, **kwargs):
+        super().__init__(**kwargs)
+
+        self.define_pars(
+            diseases = None,
+            src = None, # None indicates all alive agents. Try also AgeGroup(low=5, high=25) or ss.uids([2,3,4]) or lambda(sim): sim.people.age<25
+            dst = None, # Same as src
+            beta = ss.beta(0.2),
+            contacts = ss.poisson(lam=1),
+        )
+        self.update_pars(pars, **kwargs)
+
+        self.define_states(
+            ss.FloatArr('eff_contacts', default=self.pars.contacts, label='Effective number of contacts')
+        )
+
+        self.pars.diseases = sc.promotetolist(self.pars.diseases)
+        self.diseases = None
+
+        self.src_uids = None
+        self.dst_uids = None
+
+        self.p_acquire = ss.bernoulli(p=0) # Placeholder value
+
+        return
+
+    def init_post(self):
+        super().init_post()
+
+        if len(self.pars.diseases) == 0:
+            self.diseases = [d for d in self.sim.diseases.values() if isinstance(d, ss.Infection)] # Assume the user wants all communicable diseases
+        else:
+            self.diseases = []
+            for d in self.pars.diseases:
+                if not isinstance(d, str):
+                    raise Exception(f'Diseases can be specified as ss.Disease objects or strings, not {type(d)}')
+                if d not in self.sim.diseases:
+                    raise Exception(f'Could not find disease with name {d} in the list of diseases.')
+                dis = self.sim.diseases[d]
+                if not isinstance(dis, ss.Infection):
+                    raise Exception(f'Cannot create a mixing pool for disease {d}. Mixing pools only work for communicable diseases.')
+                self.diseases.append(dis)
+
+            if len(self.diseases) == 0:
+                raise Exception('You must specify at least one transmissible disease to use mixing pools')
+        return
+
+    def get_uids(self, func_or_array):
+        if func_or_array is None:
+            return self.sim.people.auids
+        elif callable(func_or_array):
+            return func_or_array(self.sim)
+        elif isinstance(func_or_array, ss.uids):
+            return func_or_array
+        raise Exception('src must be either a callable function, e.g. lambda sim: ss.uids(sim.people.age<5), or an array of uids.')
+
+    def start_step(self):
+        super().start_step()
+        self.src_uids = self.get_uids(self.pars.src)
+        self.dst_uids = self.get_uids(self.pars.dst)
+        return
+
+    def step(self):
+        super().step()
+
+        if self.pars.beta == 0:
+            return 0
+
+        n_new_cases = 0
+        for disease in self.diseases:
+            trans = np.mean(disease.infectious[self.src_uids] * disease.rel_trans[self.src_uids])
+            acq = self.eff_contacts[self.dst_uids] * disease.susceptible[self.dst_uids] * disease.rel_sus[self.dst_uids]
+            p = self.pars.beta * trans * acq #1 - np.exp(-self.pars.beta * trans * acq)
+
+            self.p_acquire.set(p=p)
+            new_cases = self.p_acquire.filter(self.dst_uids)
+            n_new_cases += len(new_cases)
+
+            disease.set_prognoses(new_cases)
+
+        return n_new_cases
\ No newline at end of file
diff --git a/starsim/modules.py b/starsim/modules.py
index e8039aae..03548c61 100644
--- a/starsim/modules.py
+++ b/starsim/modules.py
@@ -55,7 +55,7 @@ class Module(sc.quickobj):
         dt (float): the timestep (e.g. 1.0, 0.1); inherits from sim if not supplied
     """
 
-    def __init__(self, name=None, label=None, unit=None, dt=None):
+    def __init__(self, name=None, label=None, unit=None, dt=None, **kwargs):
         # Handle parameters
         self.pars = ss.Pars() # Usually populated via self.define_pars()
         self.set_metadata(name, label) # Usually reset as part of self.update_pars()
diff --git a/starsim/parameters.py b/starsim/parameters.py
index db378ca4..3bc05393 100644
--- a/starsim/parameters.py
+++ b/starsim/parameters.py
@@ -68,6 +68,8 @@ def update(self, pars=None, create=False, **kwargs):
                     self._update_dist(key, old, new)
                 elif callable(old): # It's a function: update directly
                     self[key] = new
+                elif isinstance(old, dict):
+                    self[key] = new # Take dictionaries directly, without warning the user
                 else: # Everything else; not used currently but could be
                     warnmsg = f'No known mechanism for handling {type(old)} → {type(new)}; using default'
                     ss.warn(warnmsg)
diff --git a/starsim/sim.py b/starsim/sim.py
index 260ae6c0..b965e485 100644
--- a/starsim/sim.py
+++ b/starsim/sim.py
@@ -598,6 +598,8 @@ def plot(self, key=None, fig=None, style='fancy', show_data=True, fig_kw=None, p
                 ax.set_title(res.full_label)
                 ax.set_xlabel('Time')
 
+        if self.label is not None:
+            fig.suptitle(self.label)
         sc.figlayout(fig=fig)
 
         return fig
diff --git a/starsim/version.py b/starsim/version.py
index 12426412..23066d86 100644
--- a/starsim/version.py
+++ b/starsim/version.py
@@ -4,6 +4,6 @@
 
 __all__ = ['__version__', '__versiondate__', '__license__']
 
-__version__ = '2.0.0'
-__versiondate__ = '2024-10-01'
+__version__ = '2.0.1'
+__versiondate__ = '2024-10-11'
 __license__ = f'Starsim {__version__} ({__versiondate__}) — © 2023-2024 by IDM'


Test patch:
diff --git a/tests/baseline.json b/tests/baseline.json
index 8c6fbc9b..8ffd2ffb 100644
--- a/tests/baseline.json
+++ b/tests/baseline.json
@@ -1,26 +1,26 @@
 {
   "summary": {
     "timevec": 2010.0,
-    "births_new": 65.02970297029702,
-    "births_cumulative": 3224.019801980198,
-    "births_cbr": 29.723743148428454,
-    "deaths_new": 44.97029702970297,
-    "deaths_cumulative": 2229.108910891089,
-    "deaths_cmr": 20.555949238807358,
-    "sir_n_susceptible": 2520.4356435643563,
-    "sir_n_infected": 3626.366336633663,
-    "sir_n_recovered": 4792.089108910891,
-    "sir_prevalence": 0.33888892397890347,
-    "sir_new_infections": 130.36633663366337,
-    "sir_cum_infections": 13167.0,
-    "sis_n_susceptible": 4740.722772277228,
-    "sis_n_infected": 6244.287128712871,
-    "sis_prevalence": 0.5587172284995694,
-    "sis_new_infections": 183.87128712871288,
-    "sis_cum_infections": 18571.0,
-    "sis_rel_sus": 0.5182920328461298,
-    "n_alive": 10938.89108910891,
-    "new_deaths": 46.118811881188115,
-    "cum_deaths": 4608.0
+    "births_new": 65.38613861386139,
+    "births_cumulative": 3232.3366336633662,
+    "births_cbr": 29.71939657784897,
+    "deaths_new": 43.97029702970297,
+    "deaths_cumulative": 2173.9504950495048,
+    "deaths_cmr": 19.987069334511897,
+    "sir_n_susceptible": 2535.2475247524753,
+    "sir_n_infected": 3639.3861386138615,
+    "sir_n_recovered": 4825.891089108911,
+    "sir_prevalence": 0.33906584103420456,
+    "sir_new_infections": 130.03960396039605,
+    "sir_cum_infections": 13134.0,
+    "sis_n_susceptible": 4668.079207920792,
+    "sis_n_infected": 6377.524752475248,
+    "sis_prevalence": 0.5669701842791725,
+    "sis_new_infections": 186.85148514851485,
+    "sis_cum_infections": 18872.0,
+    "sis_rel_sus": 0.5096541162174527,
+    "n_alive": 11000.524752475247,
+    "new_deaths": 45.07920792079208,
+    "cum_deaths": 4515.0
   }
 }
\ No newline at end of file
diff --git a/tests/benchmark.json b/tests/benchmark.json
index 992ff85b..f359e056 100644
--- a/tests/benchmark.json
+++ b/tests/benchmark.json
@@ -1,12 +1,12 @@
 {
   "time": {
     "initialize": 0.034,
-    "run": 0.913
+    "run": 0.772
   },
   "parameters": {
     "n_agents": 10000,
     "dur": 20,
     "dt": 0.2
   },
-  "cpu_performance": 0.9555946088102025
+  "cpu_performance": 0.8005978708211494
 }
\ No newline at end of file
diff --git a/tests/test_mixingpools.py b/tests/test_mixingpools.py
new file mode 100644
index 00000000..956e5dca
--- /dev/null
+++ b/tests/test_mixingpools.py
@@ -0,0 +1,206 @@
+"""
+Test Sim API
+"""
+
+# %% Imports and settings
+import pytest
+import starsim as ss
+import sciris as sc
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+
+n_agents = 1_000
+do_plot = False
+sc.options(interactive=False) # Assume not running interactively
+
+
+def test_single_defaults(do_plot=do_plot):
+    """ Test a single MixingPool using defaults """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mp = ss.MixingPool()
+    sir = ss.SIR()
+    sim = ss.Sim(diseases=sir, interventions=mp, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert(sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0]) # There were infections
+    return sim
+
+
+def test_single_uids(do_plot=do_plot):
+    """ Test a single MixingPool by UIDS, pre-initialization configuration """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+
+    n_agents = 10_000
+    k = n_agents // 2
+    mp = ss.MixingPool(
+        src = ss.uids(np.arange(k)),
+        dst = ss.uids(np.arange(k,n_agents))
+    )
+    sir = ss.SIR()
+    sim = ss.Sim(n_agents=n_agents, diseases=sir, interventions=mp, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0], 'There were no new infections in the simulation'
+    return sim
+
+
+def test_single_ncd():
+    """ Test a single MixingPool with a ncd """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mp_pars = {
+        'src': ss.AgeGroup(0, 15),
+        'dst': ss.AgeGroup(15, None),
+        'beta': ss.beta(0.15),
+        'contacts': ss.poisson(lam=5),
+        'diseases': 'ncd'
+    }
+    mp = ss.MixingPool(mp_pars)
+
+    ncd = ss.NCD()
+    sim = ss.Sim(diseases=ncd, interventions=mp, label=test_name)
+    with pytest.raises(Exception):
+        sim.run()
+    return sim
+
+
+def test_single_missing_disease():
+    """ Test a single MixingPool with a missing disease """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mp_pars = {
+        'src': ss.AgeGroup(0, 15),
+        'dst': ss.AgeGroup(15, None),
+        'beta': ss.beta(0.15),
+        'contacts': ss.poisson(lam=5),
+        'diseases': 'hiv'
+    }
+    mp = ss.MixingPool(mp_pars)
+
+    sir = ss.SIR()
+    sim = ss.Sim(diseases=sir, interventions=mp, label=test_name)
+    with pytest.raises(Exception):
+        sim.run()
+
+    return sim
+
+
+def test_single_age(do_plot=do_plot):
+    """ Test a single MixingPool by age """
+    # Incidence must decline because 0-15 --> 15+ transmission only
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mp_pars = {
+        'src': ss.AgeGroup(0, 15),
+        'dst': ss.AgeGroup(15, None),
+        'beta': ss.beta(0.15),
+        'contacts': ss.poisson(lam=5),
+    }
+    mp = ss.MixingPool(mp_pars)
+
+    sir = ss.SIR()
+    sim = ss.Sim(diseases=sir, interventions=mp, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert(sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0]) # There were infections
+    return sim
+
+
+def test_single_sex(do_plot=do_plot):
+    """ Test a single MixingPool by sex """
+    # Incidence must decline because M --> F transmission only
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mp_pars = {
+        'src': lambda sim: sim.people.female, # female to male (only) transmission
+        'dst': lambda sim: sim.people.male,
+        'beta': ss.beta(0.2),
+        'contacts': ss.poisson(lam=4),
+    }
+    mp = ss.MixingPool(mp_pars)
+
+    sir = ss.SIR(init_prev=ss.bernoulli(p=lambda self, sim, uids: 0.05*sim.people.female)) # Seed 5% of the female population
+    sim = ss.Sim(diseases=sir, interventions=mp, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert(sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0]) # There were infections
+    assert(sim.people.male[sim.diseases.sir.ti_infected>0].all()) # All new infections should be in men
+    return sim
+
+
+def test_multi_defaults(do_plot=do_plot):
+    """ Test MixingPools using defaults """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+    mps = ss.MixingPools()
+    sir = ss.SIR()
+    sim = ss.Sim(diseases=sir, interventions=mps, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert(sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0]) # There were infections
+    return sim
+
+
+def test_multi(do_plot=do_plot):
+    """ Test MixingPools """
+    test_name = sys._getframe().f_code.co_name
+    sc.heading(f'Testing {test_name}...')
+
+    groups = {
+        'Female': lambda sim: sim.people.female,
+        'Male': lambda sim: sim.people.male,
+    }
+
+    mps_pars = dict(
+        contact_matrix = np.array([[1.4, 0.5], [1.2, 0.7]]),
+        beta = ss.beta(0.2),
+        src = groups,
+        dst = groups,
+    )
+    mps = ss.MixingPools(mps_pars)
+
+    sir = ss.SIR()
+    sim = ss.Sim(diseases=sir, interventions=mps, label=test_name)
+    sim.run()
+
+    if do_plot: sim.plot()
+
+    assert(sim.results.sir['cum_infections'][-1] > sim.results.sir['cum_infections'][0]) # There were infections
+    return sim
+
+
+
+
+if __name__ == '__main__':
+    do_plot = True
+    sc.options(interactive=do_plot)
+    T = sc.timer()
+
+    sim0 = test_single_defaults(do_plot)
+    sim1 = test_single_uids(do_plot)
+    sim2 = test_single_ncd()
+    sim3 = test_single_missing_disease()
+    sim4 = test_single_age(do_plot)
+    sim5 = test_single_sex(do_plot)
+
+    sim6 = test_multi_defaults(do_plot)
+    sim7 = test_multi(do_plot)
+    sim8 = test_multi_ses(do_plot)
+
+    T.toc()
+
+    if do_plot:
+        plt.show()