Beispiel #1
0
    def test_lattice(self):
        # define links and network layout
        N_side = 20
        N = N_side**2
        links = get_2D_lattice_links(N_side,
                                     periodic=True,
                                     diagonal_links=True)
        network = get_grid_layout(N)

        # define model
        R0 = 3
        recovery_rate = 1 / 8
        model = StochasticSIRModel(N,
                                   R0,
                                   recovery_rate,
                                   edge_weight_tuples=links)
        model.set_random_initial_conditions({'I': 20, 'S': N - 20})

        sampling_dt = 2

        visualize(model,
                  network,
                  sampling_dt,
                  config={
                      'draw_nodes_as_rectangles': True,
                      'draw_links': False,
                      'show_legend': False,
                      'show_curves': False,
                  })
Beispiel #2
0
    def __init__(self,u,v,k,f,Du,Dv,periodic=True,diagonal_links=False,animate='u'):

        assert(u.shape == v.shape)
        assert(len(u.shape)==2)
        assert(u.shape[0] == u.shape[1])

        self.N = u.shape[0]

        self.u = u.flatten()
        self.v = v.flatten()
        self.k = k
        self.f = f
        self.Du = Du
        self.Dv = Dv
        self.animate = animate

        links = get_2D_lattice_links(self.N,periodic=periodic,diagonal_links=diagonal_links)

        row = []
        col = []
        data = []

        for u,v,w in links:
            row.extend([v,u,u,v])
            col.extend([u,v,u,v])
            data.extend([w, w, -w, -w])

        self.L = sprs.coo_matrix((data,(row,col)),shape=(self.N**2, self.N**2),dtype=float).tocsr()

        if animate == 'u':
            self.y0 = self.u
        else:
            self.y0 = self.v
Beispiel #3
0
from epipack.vis import visualize, get_grid_layout
from epipack import StochasticSISModel, get_2D_lattice_links

if __name__ == "__main__":

    N_side = 100
    N = N_side**2
    network = get_grid_layout(N)
    edge_list = get_2D_lattice_links(N_side,
                                     periodic=True,
                                     diagonal_links=False)

    R0 = 3
    recovery_rate = 1 / 8
    model = StochasticSISModel(N,
                               R0,
                               recovery_rate,
                               edge_weight_tuples=edge_list)
    model.set_random_initial_conditions({'I': 20, 'S': N - 20})

    sampling_dt = 1

    visualize(model,
              network,
              sampling_dt,
              config={
                  'draw_nodes_as_rectangles': True,
                  'show_legend': False
              })
from epipack import MatrixEpiModel, get_2D_lattice_links
from epipack.vis import visualize_reaction_diffusion, get_grid_layout
import numpy as np

from time import time

start = time()

N_side = 30
N = N_side**2
links = get_2D_lattice_links(N_side, periodic=False, diagonal_links=False)
network = get_grid_layout(N)

base_compartments = "SIR"

compartments = [(node, C) for node in range(N) for C in base_compartments]
model = MatrixEpiModel(compartments)

infection_rate = 2
recovery_rate = 1
mobility_rate = 0.1

quadratic_processes = []
linear_processes = []

print("defining processes")

for node in range(N):
    quadratic_processes.append(
        ((node, "S"), (node, "I"), infection_rate, (node, "I"), (node, "I")), )
Beispiel #5
0
from epipack.vis import visualize, get_grid_layout
from epipack import get_2D_lattice_links

if __name__ == "__main__":
    import netwulf as nw
    from epipack import StochasticEpiModel
    import networkx as nx

    N_side = 200
    N = N_side * N_side

    links = get_2D_lattice_links(N_side, periodic=True, diagonal_links=True)
    #links = get_2D_lattice_links(N_side,periodic=True,diagonal_links=False)

    network = get_grid_layout(N, links, windowwidth=400)

    k0 = 2 * len(links) / N

    model = StochasticEpiModel(
        list("SIRXTQ"),
        N=N,
        edge_weight_tuples=links,
    )
    Reff = 3
    R0 = 10
    recovery_rate = 1 / 8
    quarantine_rate = 1 / 32
    tracing_rate = 1 / 2
    waning_immunity_rate = 1 / 14
    infection_rate = Reff * (recovery_rate + quarantine_rate) / k0
    infection_rate = R0 * (recovery_rate) / k0