EoN module

Introduction

EoN (Epidemics on Networks) is a Python package for the simulation of epidemics on networks and solving ODE models of disease spread.

The algorithms are based on the book

Mathematics of Epidemics on Networks: from Exact to Approximate Models by Kiss, Miller & Simon (possibly freely available for download here depending on your institutional subscription).

Please cite the book if using these algorithms.

If you use EoN, please - cite the Journal of Open Source Software publication - leave a note here

This helps me get promoted / get funding, and it makes me happy when people use the software. A happy developer whose job prospects are improving because of all the people using the software will work to improve the software.

For simulations, we assume that input networks are NetworkX graphs; see https://networkx.github.io/

EoN consists of several sets of algorithms.

  • The first deals with stochastic simulation of epidemics on networks. The most significant of these are fast_SIS and fast_SIR which usually outperform Gillespie algorithms (also included). These algorithms are discussed in more detail in the appendix of the book.
  • A significant extension of these simulations is a set of tools designed to visualize and animate simulated epidemics, and generally help investigate a given stochastic simulation.
  • Another set deals with numerical solution of systems of analytic equations derived in the book. For these it is possible to either provide the degree distribution, or simply use a network and let the code determine the degree distribution.
  • There are a few additional algorithms which are not described in the book, but which we believe will be useful. Most notably, related to visualization and generation of animations.

Distributed under MIT license. See license.txt for full details.

Simulation Toolkit

This submodule deals with epidemic simulation. We start with a quick list of the functions with links to the individual functions. A brief description is below.

Quick list

fast_SIR(G, tau, gamma[, initial_infecteds, …]) fast SIR simulation for exponentially distributed infection and recovery times
fast_nonMarkov_SIR(G[, trans_time_fxn, …]) A modification of the algorithm in figure A.3 of Kiss, Miller, & Simon to allow for user-defined rules governing time of transmission.
fast_SIS(G, tau, gamma[, initial_infecteds, …]) Fast SIS simulations for epidemics on weighted or unweighted networks, allowing edge and node weights to scale the transmission and recovery rates.
fast_nonMarkov_SIS(G[, trans_time_fxn, …]) Similar to fast_nonMarkov_SIR.
Gillespie_SIR(G, tau, gamma[, …]) Performs SIR simulations for epidemics.
Gillespie_SIS(G, tau, gamma[, …]) Performs SIS simulations for epidemics on networks with or without weighted edges.
Gillespie_Arbitrary(G, …[, tmin, tmax, …]) Calls Gillespie_simple_contagion.
Gillespie_simple_contagion(G, …[, tmin, …]) Performs simulations for epidemics, allowing more flexibility than SIR/SIS.
Gillespie_complex_contagion(G, …[, tmin, …]) Initially intended for a complex contagion.
basic_discrete_SIR(G, p[, …]) Performs simple discrete SIR simulation assuming constant transmission probability p.
basic_discrete_SIS(G, p[, …]) Does a simulation of the simple case of all nodes transmitting with probability p independently to each susceptible neighbor and then recovering.
discrete_SIR(G[, test_transmission, args, …]) Simulates an SIR epidemic on G in discrete time, allowing user-specified transmission rules
percolate_network(G, p) Performs percolation on a network G with each edge persisting with probability p
directed_percolate_network(G, tau, gamma[, …]) performs directed percolation, assuming that transmission and recovery are Markovian
nonMarkov_directed_percolate_network_with_timing(G, …) Performs directed percolation on G for user-specified transmission time and recovery time distributions.
nonMarkov_directed_percolate_network(G, xi, …) performs directed percolation on a network following user-specified rules.
estimate_SIR_prob_size(G, p) Uses percolation to estimate the probability and size of epidemics assuming constant transmission probability p
estimate_SIR_prob_size_from_dir_perc(H) Estimates probability and size of SIR epidemics for an input network after directed percolation
estimate_directed_SIR_prob_size(G, tau, gamma) Predicts probability and attack rate assuming continuous-time Markovian SIR disease on network G
estimate_nonMarkov_SIR_prob_size_with_timing(G, …) estimates probability and size for user-input transmission and recovery time functions.
estimate_nonMarkov_SIR_prob_size(G, xi, …) Predicts epidemic probability and size using nonMarkov_directed_percolate_network.
get_infected_nodes(G, tau, gamma[, …]) Finds all eventually infected nodes in an SIR simulation, through a percolation approach
percolation_based_discrete_SIR(G, p[, …]) perfoms a simple SIR epidemic but using percolation as the underlying method.

Short descriptions

  • Event-based algorithms:

    These algorithms use an efficient approach to simulate epidemics. fast_SIR and fast_SIS assume constant transmission and recovery rates, while fast_nonMarkov_SIR and fast_nonMarkov_SIS allow the user to specify more detailed rules for transmission.

    • fast_SIR
    • fast_nonMarkov_SIR
    • fast_SIS
    • fast_nonMarkov_SIS

  • Gillespie Algorithms

    These algorithms simulate epidemics assuming constant transmission and recovery rates. They are commonly used, but in many cases are slower than the event driven methods. I do not see evidence that they are ever significantly faster. It is not very practical to get away from the constant rate assumptions so I prefer to avoid them. However, Gillespie_simple_contagion allows the user to do SEIR, SIRS, or any of a number of other more exotic “simple contagion” scenarios that are not in the event-driven code. Gillespie_complex_contagion handles complex contagions, in which an individual requires multiple partners to have a given state before it changes status. For legacy reasons, Gillespie_Arbitrary is included, it simply calls Gillespie_simple_contagion, and will be removed in future versions.

    • Gillespie_SIR
    • Gillespie_SIS
    • Gillespie_Arbitrary
    • Gillespie_simple_contagion
    • Gillespie_complex_contagion

  • Discrete-time algorithms

    These algirthms are appropriate for where we separate infection into generations. We assume infection lasts a single time step. The basic_* algorithms assume that transmission occurs with probability p for all edges. In contrast discrete_SIR allows for very general user-specified transmission rules.

    • basic_discrete_SIR
    • basic_discrete_SIS
    • discrete_SIR

  • Percolation-based approaches

    There is a close relation between percolation and SIR disease which is described in Chapter 6 of the book. Many of these algorithms are related to demonstrating the equivalence as outlined in the book, and are not really the most efficient way to simulate an epidemic. However, these algorithms will be useful for estimating probability and size of epidemics.

    • percolate_network (undirected percolation corresponding to fixed transmission probability)
    • directed_percolate_network (directed percolation corresponding to constant transmission and recovery rates)
    • nonMarkov_directed_percolate_network_with_timing (uses user-generated duration and transmission time distributions)
    • nonMarkov_directed_percolate_network (uses user-generated transmission rules)
    • estimate_SIR_prob_size (estimates prob/size from an undirected percolated network - only appropriate if constant p)
    • estimate_SIR_prob_size_from_dir_perc (estimates epi prob and size from a given percolated network)
    • estimate_directed_SIR_prob_size (estimates based on constant transmission and recovery rates)
    • estimate_nonMarkov_SIR_prob_size_with_timing (estimates based on user-generated transmission and recovery time distributions)
    • estimate_nonMarkov_SIR_prob_size (estimates based on user-generated transmission rules)
    • get_infected_nodes (simulates epidemic and returns final infected nodes)
    • percolation_based_discrete_SIR

Simulation Investigation toolkit

We can study simulations in detail through the Simulation_Investigation class. This includes automated generation of animations.

This is particularly useful if we want to look at time series or at animations of the network as the disease spreads.

When EoN performs a simulation with return_full_data set to True, it returns a Simulation_Investigation object. At it’s core, this has the data about when each node changed status and what its new status became. This allows us to generate plots of the network at any given instance in time and to produce animations.

The basic display produced by a Simulation_Investigation object shows the network at a given snapshot in time on the left, and on the right it shows the time series of S, I, and (if SIR) R. It has the option to add additional curves that might have been calculated by an analytic model, or perhaps another simulation.

In general, any of the dynamic simulations will produce a Simulation_Investigation object if we pass it return_full_data = True.

Some examples appear in section Visualizing or animating disease spread.

Quick list

display(time[, ts_plots, ts_list, nodelist, …]) Provides a plot of the network at a specific time and (optionally) some of the time series
animate([frame_times, ts_plots, ts_list, …]) As in display, but this produces an animation.
node_history(node) returns the history of a node.
node_status(node, time) returns the status of a given node at a given time.
get_statuses([nodelist, time]) returns the status of nodes at a given time.
summary([nodelist]) Provides the population-scale summary of the dynamics.
t() Returns the times of events Generally better to get these all through summary()
S() If 'S' is a state, then this will return the number susceptible at each time.
I() See notes for S
R() See notes for S
transmissions() Returns a list of tuples (t,u,v) stating that node u infected node v at time t.
transmission_tree() Produces a MultiDigraph whose edges correspond to transmission events.
add_timeseries(ts_data[, color_dict, label, tex]) This allows us to include some additional timeseries for comparision with the simulation.
update_ts_kwargs(ts, **kwargs) Allows us to change some of the matplotlib key word arguments for a timeseries object
update_ts_label(ts, label) updates the label for time series plots
update_ts_color_dict(ts, color_dict) updates the color_dict for time series plots
update_ts_tex(ts, tex) updates the tex flag for time series plots
sim_update_kwargs(**kwargs) Allows us to change some of the matplotlib key word arguments for the simulation.
sim_update_label(label) updates the label for the simulation in the time series plots
sim_update_color_dict(color_dict) updates the color_dict for the simulation
sim_update_tex(tex) updates the tex flag for the simulation in the time series plots and in the network plots
set_pos(pos) Set the position of the nodes.

Short description

  • Visualizations

    There are two main commands for visualization. We can either produce a snapshot at a given time, or produce an animation. In either case we can optionally include plots of S, I, (and R) as functions of time.

    • display (allows us to plot a graph at a specific time
      point, and to optionally include the calculated time series)
    • animate (allows us to plot a graph at many time points
      We can create a visualization such as mp4, or save each individual frame of an animation. The time series are optional.

  • Data about simulation

    Often we’ll want to be able to check what happened to specific nodes in the network, or we’ll want to know what the time history of the outbreak looked like

    • node_history
    • node_status returns the status of a node at a given time
    • get_statuses returns the status of a collection of nodes at
      a given time (in a dict).
    • summary returns t, S, I, (and if SIR R) for the population (or a subset of the population)
    • t
    • S
    • I
    • R
    • transmissions returns a list of 3-tuples of the form (t, u, v) stating that u transmitted to v at time t.
    • transmission_tree returns a MultiDiGraph where an edge from u to v with attribute time = t means that u transmitted to v at time t. (For SIR this is a tree or a forest).

  • Details for plotting

    The remaining commands are to do with the specifics of how the plots appear

    • update_ts_kwargs
    • update_ts_label
    • update_ts_colordict
    • update_ts_tex
    • sim_update_kwargs
    • sim_update_label
    • sim_update_colordict
    • sim_update_tex
    • set_pos

  • Plotting of transmission tree

Analytic Toolkit

This submodule deals with solution to systems of equations appearing in the book. The majority of these also have a version that take a graph G. There are additional functions that calculate properties which these need.

Quick list

SIS_individual_based(G, tau, gamma[, rho, …]) Encodes System (3.7) of Kiss, Miller, & Simon.
SIS_individual_based_pure_IC(G, tau, gamma, …) Encodes System (3.7) of Kiss, Miller, & Simon.
SIS_pair_based(G, tau, gamma[, rho, …]) Encodes System (3.26) of Kiss, Miller, & Simon.
SIS_pair_based_pure_IC(G, tau, gamma, …[, …]) Encodes System (3.26) of Kiss, Miller, & Simon, using a “pure initial condition”.
SIR_individual_based(G, tau, gamma[, rho, …]) Encodes System (3.30) of Kiss, Miller, & Simon.
SIR_individual_based_pure_IC(G, tau, gamma, …) Encodes System (3.30) of Kiss, Miller, & Simon.
SIR_pair_based(G, tau, gamma[, rho, …]) Encodes System (3.39) of Kiss, Miller, & Simon.
SIR_pair_based_pure_IC(G, tau, gamma, …[, …]) Encodes System (3.39) of Kiss, Miller, & Simon, using a “pure initial condition”.
SIS_homogeneous_meanfield(S0, I0, n, tau, gamma) Encodes System (4.8) of Kiss, Miller, & Simon.
SIR_homogeneous_meanfield(S0, I0, R0, n, …) Encodes System (4.9) of Kiss, Miller, & Simon.
SIS_homogeneous_pairwise(S0, I0, SI0, SS0, …) Encodes System (4.10) of Kiss, Miller, & Simon.
SIS_homogeneous_pairwise_from_graph(G, tau, …) Calls SIS_homogeneous_pairwise after calculating S0, I0, SI0, SS0, n based on the graph G and initial fraction infected rho.
SIR_homogeneous_pairwise(S0, I0, R0, SI0, …) Encodes System (4.11) of Kiss, Miller, & Simon.
SIR_homogeneous_pairwise_from_graph(G, tau, …) Calls SIR_homogeneous_pairwise after calculating S0, I0, R0, SI0, SS0, n, based on the graph G and initial fraction infected rho.
SIS_heterogeneous_meanfield(Sk0, Ik0, tau, gamma) Encodes System (5.10) of Kiss, Miller, & Simon.
SIS_heterogeneous_meanfield_from_graph(G, …) Calls SIS_heterogeneous_meanfield after calculating Sk0, Ik0 based on the graph G and random fraction infected rho.
SIR_heterogeneous_meanfield(Sk0, Ik0, Rk0, …) Encodes System (5.11) of Kiss, Miller, & Simon.
SIR_heterogeneous_meanfield_from_graph(G, …) Calls SIR_heterogeneous_meanfield after calculating Sk0, Ik0, Rk0 based on a graph G and initial fraction infected rho.
SIS_heterogeneous_pairwise(Sk0, Ik0, SkSl0, …) Encodes System (5.13) of Kiss, Miller, & Simon.
SIS_heterogeneous_pairwise_from_graph(G, …) Calls SIS_heterogeneous_pairwise after calculating Sk0, Ik0, SkSl0, SkIl0, IkIl0 from a graph G and initial fraction infected rho.
SIR_heterogeneous_pairwise(Sk0, Ik0, Rk0, …) Encodes System (5.15) of Kiss, Miller, & Simon.
SIR_heterogeneous_pairwise_from_graph(G, …) Calls SIR_heterogeneous_pairwise after calculating Sk0, Ik0, Rk0, SkSl0, SkIl0 from a graph G and initial fraction infected rho.
SIS_compact_pairwise(Sk0, Ik0, SI0, SS0, …) Encodes system (5.18) of Kiss, Miller, & Simon.
SIS_compact_pairwise_from_graph(G, tau, gamma) Calls SIS_compact_pairwise after calculating Sk0, Ik0, SI0, SS0, II0 from the graph G and initial fraction infected rho.
SIR_compact_pairwise(Sk0, I0, R0, SS0, SI0, …) Encodes system (5.19) of Kiss, Miller, & Simon.
SIR_compact_pairwise_from_graph(G, tau, gamma) Calls SIR_compact_pairwise after calculating Sk0, I0, R0, SS0, SI0 from the graph G and initial fraction infected rho.
SIS_super_compact_pairwise(S0, I0, SS0, SI0, …) Encodes system (5.20) of Kiss, Miller, & Simon.
SIS_super_compact_pairwise_from_graph(G, …) Calls SIS_super_compact_pairwise after calculating S0, I0, SS0, SI0, II0 from the graph G and initial fraction infected rho
SIR_super_compact_pairwise(R0, SS0, SI0, N, …) Encodes system (5.22) of Kiss, Miller, & Simon.
SIR_super_compact_pairwise_from_graph(G, …) Calls SIR_super_compact_pairwise after calculating R0, SS0, SI0 from the graph G and initial fraction infected rho
SIS_effective_degree(Ssi0, Isi0, tau, gamma) Encodes system (5.36) of Kiss, Miller, & Simon. Please cite the
SIS_effective_degree_from_graph(G, tau, gamma) Calls SIS_effective_degree after calculating Ssi0, Isi0 from the graph G and initialf fraction infected rho.
SIR_effective_degree(S_si0, I0, R0, tau, gamma) Encodes system (5.38) of Kiss, Miller, & Simon.
SIR_effective_degree_from_graph(G, tau, gamma) Calls SIR_effective_degree after calculating S_si0, I0, R0 from the graph G and initial fraction infected rho
SIR_compact_effective_degree(Skappa0, I0, …) Encodes system (5.43) of Kiss, Miller, & Simon.
SIR_compact_effective_degree_from_graph(G, …) Calls SIR_compact_effective_degree after calculating Skappa0, I0, R0, SI0 from the graph G and initial fraction infected rho.
SIS_compact_effective_degree(Sk0, Ik0, SI0, …) Encodes system (5.44) of Kiss, Miller, & Simon.
SIS_compact_effective_degree_from_graph(G, …) because the SIS compact effective degree model is identical to the compact pairwise model, simply calls SIS_compact_pairwise_from_graph
Epi_Prob_discrete(Pk, p[, number_its]) Encodes System (6.2) of Kiss, Miller, & Simon.
Epi_Prob_cts_time(Pk, tau, gamma[, umin, …]) Encodes System (6.3) of Kiss, Miller, & Simon.
Epi_Prob_non_Markovian(Pk, Pxidxi, po[, …]) Encodes system (6.5) of Kiss, Miller, & Simon.
Attack_rate_discrete(Pk, p[, rho, Sk0, …]) Encodes systems (6.6) and (6.10) of Kiss, Miller, & Simon.
Attack_rate_discrete_from_graph(G, p[, …]) if initial_infecteds and initial_recovereds is defined, then it will find Sk0, phiS0, and phiR0 and then call Attack_rate_discrete.
Attack_rate_cts_time(Pk, tau, gamma[, …]) Encodes system (6.7) of Kiss, Miller, & Simon.
Attack_rate_cts_time_from_graph(G, tau, gamma) Given a graph, predicts the attack rate for Configuration Model networks with the given degree distribution.
Attack_rate_non_Markovian(Pk, Pzetadzeta, pi) Encodes system (6.8) of Kiss, Miller, & Simon.
Attack_rate_discrete(Pk, p[, rho, Sk0, …]) Encodes systems (6.6) and (6.10) of Kiss, Miller, & Simon.
EBCM_discrete(N, psihat, psihatPrime, p, phiS0) Encodes system (6.11) of Kiss, Miller, & Simon.
EBCM_discrete_from_graph(G, p[, …]) Takes a given graph, finds the degree distribution (from which it gets psi), assumes a constant proportion of the population is infected at time 0, and then uses the discrete EBCM model.
EBCM(N, psihat, psihatPrime, tau, gamma, phiS0) Encodes system (6.12) of Kiss, Miller, & Simon.
EBCM_uniform_introduction(N, psi, psiPrime, …) Handles the case that the disease is introduced uniformly as opposed to depending on degree.
EBCM_from_graph(G, tau, gamma[, …]) Given network G and rho, calculates N, psihat, psihatPrime, and calls EBCM.
EBCM_pref_mix(N, Pk, Pnk, tau, gamma[, rho, …]) Encodes the system derived in exercise 6.21 of Kiss, Miller, & Simon.
EBCM_pref_mix_from_graph(G, tau, gamma[, …]) Takes a given graph, finds degree correlations, and calls EBCM_pref_mix
EBCM_pref_mix_discrete(N, Pk, Pnk, p[, rho, …]) Encodes the discrete version of exercise 6.21 of Kiss, Miller, & Simon.
EBCM_pref_mix_discrete_from_graph(G, p[, …]) Takes a given graph, finds degree correlations, and calls EBCM_pref_mix_discrete
get_Pk(G) Used in several places so that we can input a graph and then we can call the methods that depend on the degree distribution
get_PGF(Pk) Given a degree distribution (as a dict), returns the probability generating function
get_PGFPrime(Pk) Given a degree distribution (as a dict) returns the function \(\psi'(x)\)
get_PGFDPrime(Pk) Given a degree distribution (as a dict) returns the function \(\psi''(x)\)
estimate_R0(G[, tau, gamma, transmissibility]) provides the estimate of the reproductive number R_0 = T <K^2-K>/<K>

Short description

These come from the book. The numbers given below are the equation numbers in the book.

  • Chapter 3

    This chapter deals with models assuming we know the full network structure.

    • System (3.7): SIS model: Closes equations by assuming that knowing the probabilities for nodes to have each status is enough to predict impact of their interactions (ignores temporal correlation between statuses of neighbors).

      • SIS_individual_based
      • SIS_individual_based_pure_IC

      The pure_IC version assumes that some nodes begin infected with probability 1 and the others are susceptible with probability 1.

    • System (3.26): assumes that tracking pair correlations is enough. Many more equations than individual-based.

      • SIS_pair_based
      • SIS_pair_based_pure_IC

    • System (3.30) SIR equivalent of corresponding SIS model.

      • SIR_individual_based
      • SIR_individual_based_pure_IC

    • System (3.39) SIR equivalent of corresponding SIS model.

      • SIR_pair_based
      • SIR_pair_based_pure_IC

  • Chapter 4

    This chapter attempts to approximate the exact dynamics by ignoring heterogeneity in degree.

    • System (4.8) Assumes dynamics determined by average number of contacts and number of nodes of each status.

      • SIS_homogeneous_meanfield

    • System (4.9) As for SIS.

      • SIR_homogeneous_meanfield

    • System (4.10) Assumes dynamics are determined by the average number of contacts, nodes of each status, and pairs of each status.

      • SIS_homogeneous_pairwise
      • SIS_homogeneous_pairwise_from_graph (reads properties from input graph)

    • System (4.11)

      • SIR_homogeneous_pairwise
      • SIR_homogeneous_pairwise_from_graph

  • Chapter 5

    This chapter attempts to approximate the exact dynamics and incorporates heterogeneity in degree (at the cost of more complex models)

    • System (5.10)

      • SIS_heterogeneous_meanfield
      • SIS_heterogeneous_meanfield_from_graph

    • System (5.11)

      • SIR_heterogeneous_meanfield
      • SIR_heterogeneous_meanfield_from_graph

    • System (5.13)

      • SIS_heterogeneous_pairwise
      • SIS_heterogeneous_pairwise_from_graph

    • System (5.15)

      • SIR_heterogeneous_pairwise
      • SIR_heterogeneous_pairwise_from_graph

    • System (5.18)

      • SIS_compact_pairwise
      • SIS_compact_pairwise_from_graph

    • System (5.19)

      • SIR_compact_pairwise
      • SIR_compact_pairwise_from_graph

    • System (5.20)

      • SIS_super_compact_pairwise
      • SIS_super_compact_pairwise_from_graph

    • System (5.22)

      • SIR_super_compact_pairwise
      • SIR_super_compact_pairwise_from_graph

    • System (5.36)

      • SIS_effective_degree
      • SIS_effective_degree_from_graph

    • System (5.38)

      • SIR_effective_degree
      • SIR_effective_degree_from_graph

    • System (5.43)

      • SIR_compact_effective_degree
      • SIR_compact_effective_degree_from_graph

    • System (5.44)

      • SIS_compact_effective_degree
      • SIS_compact_effective_degree_from_graph

  • Chapter 6

    This chapter uses percolation-based techniques to explore epidemic properties.

    • System (6.2) Given a degree distribution and uniform transmission probability, find epidemic probability.

      • Epi_Prob_discrete

    • System (6.3) As in 6.2, but assuming constant transmission and recovery rates.

      • Epi_Prob_cts_time

    • System (6.5) As in 6.2, but with user-specified transmission rules

      • Epi_Prob_non_Markovian

    • System (6.6) Given a degree distribution, initial proportion infected, and transmission probability, find attack rate. See also System (6.10).

      • Attack_rate_discrete
      • Attack_rate_discrete_from_graph

    • System (6.7) as in 6.6, but assuming constant transmission and recovery rates.

      • Attack_rate_cts_time
      • Attack_rate_cts_time_from_graph

    • System (6.8) As in 6.6, but with user-specified transmission rules

      • Attack_rate_non_Markovian

    • System (6.10) See code for System (6.6).

    • System (6.11) Perform EBCM calculations for discrete-time.

      • EBCM_discrete
      • EBCM_discrete_from_graph

    • System (6.12) Perform EBCM calculations for continuous-time.

      • EBCM allows initial status to be degree dependant.
      • EBCM_uniform_introduction assumes disease introduced at t=0 uniformly at random
      • EBCM_from_graph assumes disease introduced at t=0 uniformly at random in network of given degree distribution.
    • exercise 6.21 Deals with the EBCM model assuming preferential mixing.
      • EBCM_pref_mix
      • EBCM_pref_mix_from_graph
      • EBCM_pref_mix_discrete
      • EBCM_pref_mix_discrete_from_graph

Auxiliary Functions

We have a few additional functions which are of value.

Quick List

get_time_shift(times, L, threshold) Identifies the first time at which list/array L crosses a threshold.
subsample(report_times, times, status1[, …]) Given a list/array of times to report at, returns the number of nodes of each status at those times.
hierarchy_pos(G[, root, width, vert_gap, …]) If the graph is a tree this will return the positions to plot this in a hierarchical layout.

Short Description

  • get_time_shift (allows us to shift plots to eliminate the effect of early-time stochasticity)
  • subsample (allows us to take output given at a stochastic set of times and get output at given times - particularly useful to allow for averaging multiple simulations)
  • hierarchy_pos (Provides positions that help visualize the transmission chain from a Simulation_Investigation object)