def intervene(self, intervention_entry):
print('intervening')
if self._N == 0:
self._N = len(self._adjlist)
frac_of_network = self.proportion_reduced_list[
intervention_entry] * self._N
how_many = 0
if frac_of_network > 1:
how_many = int(np.round(frac_of_network, 0))
vaccinated_nodes = []
random_set = self.vax_queue[:how_many]
for i, node_label in enumerate(random_set):
if self.use_uniform_rate:
candidate_node = network.Node(node_label, -1, None,
self._uniform_gamma)
else:
candidate_node = network.Node(node_label, -1, None,
self._Gamma[node_label])
if self.track_memberships:
candidate_node.set_membership(
self._node_memberships[candidate_node.get_label()])
existing_node = self._existing_node(candidate_node)
# all the nodes become active
if existing_node.get_state() != nodestate.NodeState.VACCINATED:
# these should also be added to the active nodes
if existing_node.get_state() != nodestate.NodeState.INFECTED:
existing_node.vaccinate()
vaccinated_nodes.append(existing_node)
self._update_IS_events(recovery_event=existing_node)
self.vax_queue = self.vax_queue[how_many:]
return vaccinated_nodes
def intervene(self):
print('intervening')
if self._N == 0:
self._N = len(self._adjlist)
vaccinated_nodes = []
vax_labels = []
random_set = list(
np.where(
np.random.uniform(0, 1, self._N) <= self.proportion_reduced)
[0])
for node_label in random_set:
if self.use_uniform_rate:
candidate_node = network.Node(node_label, -1, None,
self._uniform_gamma)
else:
candidate_node = network.Node(node_label, -1, None,
self._Gamma[node_label])
if self.track_memberships:
candidate_node.set_membership(
self._node_memberships[candidate_node.get_label()])
existing_node = self._existing_node(candidate_node)
if existing_node.get_state() != nodestate.NodeState.VACCINATED:
if existing_node.get_state() != nodestate.NodeState.INFECTED:
existing_node.vaccinate()
vaccinated_nodes.append(existing_node)
vax_labels.append(node_label)
# self._Beta[node_label] = np.full(N, self.beta_redux)
# self._Beta[:, node_label] = np.full(N, self.beta_redux).T
self._update_IS_events(recovery_event=existing_node)
def intervene(self):
print('intervening')
if self._N == 0:
self._N = len(self._adjlist)
frac_of_network = self.proportion_reduced * self._N
how_many = 0
if frac_of_network > 1:
how_many = int(np.round(frac_of_network, 0))
degrees = list([len(neighbor) - 1 for neighbor in self._adjlist])
degree_classes = {}
for i in range(len(degrees)):
degree = degrees[i]
try:
degree_classes[degree].append(i)
except KeyError:
degree_classes[degree] = [i]
keys_decreasing = np.sort(list(degree_classes.keys()))[::-1]
num_vaccinated = 0
infct_hd_nodes = 0
for degree in keys_decreasing:
current_node_group = degree_classes[
degree] # To match analytical prediction, once a degree class is bumped up to meet the quota, the whole class is vaccinated
if num_vaccinated < how_many:
for node in current_node_group:
if self.use_uniform_rate:
candidate_node = network.Node(node, -1, None,
self._uniform_gamma)
else:
candidate_node = network.Node(node, -1, None,
self._Gamma[node])
if self.track_memberships:
candidate_node.set_membership(
self._node_memberships[candidate_node.get_label()])
existing_node = self._existing_node(candidate_node)
if existing_node.get_state(
) != nodestate.NodeState.VACCINATED:
if existing_node.get_state(
) != nodestate.NodeState.INFECTED: #Do not vaccinate currently infected nodes
existing_node.vaccinate()
num_vaccinated += 1
else:
infct_hd_nodes += 1 # Counts high-degree currently infected nodes
else:
num_vaccinated += 1 # INCREMENT ANYWAY, still counts as one of the vaccinated quota despite not being elligible.
self._update_IS_events(recovery_event=existing_node)
print(
f"Number of already infected nodes: {infct_hd_nodes}, which is {(infct_hd_nodes/how_many)} percent of the projected vacine proportion"
)
def test_edge(self):
first_node = network.Node(label=1,
generation=0,
state=nodestate.NodeState.SUSCEPTIBLE,
event_rate=.1)
second_node = network.Node(label=2,
generation=1,
state=nodestate.NodeState.INFECTED,
event_rate=.2)
edge = network.Edge(first_node, second_node, event_rate=0.5)
should_be_same_edge = network.Edge(first_node,
second_node,
event_rate=0.4)
self.assertTrue(edge.equals(should_be_same_edge))
def intervene(self, intervention_entry):
if self._N == 0:
self._N = len(self._adjlist)
frac_of_network = self.proportion_reduced_list[
intervention_entry] * self._N
how_many = 0
if frac_of_network > 1:
how_many = int(np.round(frac_of_network, 0))
degrees = list([len(neighbor) - 1 for neighbor in self._adjlist])
degree_classes = {}
for i in range(len(degrees)):
degree = degrees[i]
try:
degree_classes[degree].append(i)
except KeyError:
degree_classes[degree] = [i]
keys_decreasing = np.sort(list(degree_classes.keys()))[::-1]
num_vaccinated = 0
infct_hd_nodes = 0
for degree in keys_decreasing:
current_node_group = degree_classes[degree]
if num_vaccinated < how_many:
for node in current_node_group:
if self.use_uniform_rate:
candidate_node = network.Node(node, -1, None,
self._uniform_gamma)
else:
candidate_node = network.Node(node, -1, None,
self._Gamma[node])
if self.track_memberships:
candidate_node.set_membership(
self._node_memberships[candidate_node.get_label()])
existing_node = self._existing_node(candidate_node)
if existing_node.get_state(
) != nodestate.NodeState.VACCINATED:
if existing_node.get_state(
) != nodestate.NodeState.INFECTED: #Do not vaccinate currently infected nodes
existing_node.vaccinate()
num_vaccinated += 1
else:
infct_hd_nodes += 1 # Counts high-degree currently infected nodes
else:
num_vaccinated += 1 # INCREMENT ANYWAY, still counts as one of the vaccinated quota despite not being elligible.
self._update_IS_events(recovery_event=existing_node)
def test_node(self):
first_node = network.Node(label=1,
generation=0,
state=nodestate.NodeState.SUSCEPTIBLE,
event_rate=.1)
second_node = network.Node(label=2,
generation=1,
state=nodestate.NodeState.INFECTED,
event_rate=.2)
self.assertFalse(first_node.equals(second_node))
first_node.infect()
self.assertEqual(first_node._state, nodestate.NodeState.INFECTED)
first_node.recover()
self.assertEqual(first_node._state, nodestate.NodeState.RECOVERED)
third_node_same_label = network.Node(
label=1,
generation=0,
state=nodestate.NodeState.SUSCEPTIBLE,
event_rate=0.1)
self.assertTrue(third_node_same_label.equals(first_node))
def test_edge_infection(self):
first_node = network.Node(label=1,
generation=0,
state=nodestate.NodeState.INFECTED,
event_rate=.1)
second_node = network.Node(label=2,
generation=-1,
state=nodestate.NodeState.SUSCEPTIBLE,
event_rate=.2)
self.assertEqual(first_node.get_state(), nodestate.NodeState.INFECTED)
self.assertEqual(first_node.get_generation(), 0)
self.assertEqual(second_node.get_state(),
nodestate.NodeState.SUSCEPTIBLE)
self.assertEqual(second_node.get_generation(), -1)
edge = network.Edge(first_node, second_node, event_rate=0.5)
edge.infect()
self.assertEqual(second_node.get_state(), nodestate.NodeState.INFECTED)
self.assertEqual(second_node.get_generation(), 1)