if settings.network_type == 0:
G = nx.complete_graph(settings.number_of_nodes)
if settings.network_type == 1:
G = nx.barabasi_albert_graph(settings.number_of_nodes, 10)
if settings.network_type == 2:
G = nx.margulis_gabber_galil_graph(settings.number_of_nodes, None)
# More types of networks can be added here
##############
# Simulation #
##############
sim = NetworkSimulation(topology=G,
states=init_states,
agent_type=ControlModelM2,
max_time=settings.max_time,
num_trials=settings.num_trials,
logging_interval=1.0)
sim.run_simulation()
###########
# Results #
###########
x_values = []
infected_values = []
neutral_values = []
cured_values = []
vaccinated_values = []
attribute_plot = 'status'
seednode = random.randint(0, numberofnodes)
hashdata = string.ascii_letters
for i in range(10):
#piece={"pieceid":random.choice(hashdata),"piecesize":ps/20}
piece = {"pieceid": random.choice(hashdata), "piecesize": 0.1}
nodes[seednode]["pieces"].append(piece)
nodes[seednode]["id"] = 1
#for i in range(50,200,10):
sim = NetworkSimulation(topology=G,
agent_type=randompeerfailure,
states=nodes,
num_trials=1,
max_time=time,
logging_interval=1.0,
environmentparams={
"time": time,
"faileddict": {}
})
sim.run_simulation()
faileddict = sim.environment_params["environmentparams"]["faileddict"]
if time in faileddict.keys():
deletesizes.append(len(faileddict[time]))
else:
deletesizes.append(0)
print(deletesizes, piecesizes)
failureratios = []
# Starting out with a human population
init_states = [{'id': 0, } for _ in range(number_of_nodes)]
# Randomly seeding patient zero
patient_zero = random.randint(0, number_of_nodes)
init_states[patient_zero] = {'id': 1}
# Setting up the simulation
sim = NetworkSimulation(topology=G, states=init_states, agent_type=ZombieMassiveOutbreak,
max_time=28, num_trials=100, logging_interval=1.0, dir_path='sim_01')
# Running the simulation
sim.run_simulation()
# Starting out with a human population
init_states = [{'id': 0, } for _ in range(number_of_nodes)]
# Randomly seeding patient zero
patient_zero = random.randint(0, number_of_nodes)
init_states[patient_zero] = {'id': 1}
# Setting up the simulation
sim = NetworkSimulation(topology=G, states=init_states, agent_type=ZombieEscape,
def zombify(self):
normal_neighbors = self.get_neighboring_agents(state_id=0)
for neighbor in normal_neighbors:
if random.random() < self.bite_prob:
neighbor.state['id'] = 1 # zombie
print(self.env.now, self.id, neighbor.id, sep='\t')
break
from nxsim import NetworkSimulation
# Initialize agent states. Let's assume everyone is normal.
init_states = [{'id': 0, } for _ in range(number_of_nodes)] # add keys as as necessary, but "id" must always refer to that state category
# Seed a zombie
init_states[5] = {'id': 1}
sim = NetworkSimulation(topology=G, states=init_states, agent_type=ZombieOutbreak,
max_time=30, num_trials=1, logging_interval=1.0)
sim.run_simulation()
#%matplotlib inline
nx.draw(G)
# from nxsim import BaseLoggingAgent
# trial = BaseLoggingAgent.open_trial_state_history(dir_path='sim_01', trial_id=0)
# import numpy as np
# from matplotlib import pyplot as plt
# #%matplotlib inline
# zombie_census = [sum([1 for node_id, state in g.items() if state['id'] == 1]) for t,g in trial.items()]
# plt.plot(zombie_census)
from nxsim import NetworkSimulation
#from churnsim.uk.ac.bristol.rechurn.modes.p2p.biasedpeerselection import biasedpeerfailure
from networkx import nx
import random
numberofnodes=10
G = nx.complete_graph(numberofnodes)
failurestates={}
keys=range(numberofnodes)
for i in keys:
failurestates[i]=0
failurenode=random.randint(0,numberofnodes)
failurestates[failurenode]=1
sim=NetworkSimulation(topology=G,agent_type=randompeerselection,states=,environment_agent=,dir_path=,
num_trials=,max_time=,logging_interval=)
'id': 'node',
'active': False,
'queue': 0,
'cpu': 0,
'dropped': 0,
} for _ in range(number_of_nodes + 1)]
# Seed a balancer
init_states[0] = {'id': 'balancer', 'req_new': 0}
# Activate single node
init_states[1]['active'] = True
sim = NetworkSimulation(topology=G,
states=init_states,
agent_type=AutoScalingAgent,
max_time=period * number_of_periods,
dir_path='sim_01',
num_trials=1,
logging_interval=1.0)
sim.run_simulation()
trial = BaseLoggingAgent.open_trial_state_history(dir_path='sim_01',
trial_id=0)
# plt.interactive(False)
# req_num = [sum([state['req_new'] for node_id, state in g.items() if state['id'] == 'balancer']) for t, g in trial.items() if t > (period * (number_of_periods - 1))]
# plt.plot(req_num)
# plt.show()
# queue_size = [sum([state['queue'] for node_id, state in g.items() if state['id'] == 'node']) for t, g in trial.items()]
# More types of networks can be added here
##############
# Simulation #
##############
agents = settings.environment_params['agent']
print("Using Agent(s): {agents}".format(agents=agents))
if len(agents) > 1:
for agent in agents:
sim = NetworkSimulation(
topology=G,
states=init_states,
agent_type=locals()[agent],
max_time=settings.network_params["max_time"],
num_trials=settings.network_params["num_trials"],
logging_interval=1.0,
**settings.environment_params)
sim.run_simulation()
print(str(agent))
results(str(agent))
resultadosTipo(str(agent))
visualization(str(agent))
else:
agent = agents[0]
sim = NetworkSimulation(topology=G,
states=init_states,
agent_type=locals()[agent],
max_time=settings.network_params["max_time"],
num_trials=settings.network_params["num_trials"],
if initial_states[i] < 1:
initial_states[i] = 1
elif initial_states[i] > 5:
initial_states[i] = 5
initial_states
#plt.hist(initial_states, bins=5)
init = [{'quali-rate': state} for state in initial_states]
# Preparando a simulação
sim = NetworkSimulation(topology=G_scale_free,
states=init,
agent_type=DifusaoQualidade,
max_time=50,
num_trials=1,
logging_interval=1.0,
dir_path='quali_sim_01')
# Rodando a simulação
sim.run_simulation()
print('\n\n')
# Resultados
log = BaseLoggingAgent.open_trial_state_history(dir_path='quali_sim_01')
rates = []
for node in range(numero_de_pessoas):
rate = log[49][node]['quali-rate']