def throughput(draw=False):
'''
Throughput and expected number of tokens metrics obtained for some relevant transitions and places.
'''
print('\n\n---- Running throughput example ----')
pntools = gst.GSPNtools()
print('Importing GSPN Model')
mypn = pntools.import_xml('multi_escort_run.xml')[0]
if draw:
drawing = pntools.draw_gspn(mypn,
file=save_path + 'petri_net',
show=False)
print('Generating CT')
ct_tree = gspn_analysis.CoverabilityTree(mypn)
ct_tree.generate()
print('Bounded? : ', ct_tree.boundedness())
if draw:
pntools.draw_coverability_tree(ct_tree,
file=save_path + 'cv_tree',
show=False)
print('Generating CTMC')
ctmc = gspn_analysis.CTMC(ct_tree)
ctmc.generate()
print('CTMC States:\n')
_, ss = ct_tree.convert_states_to_latex()
# print(ss)
if draw:
pntools.draw_ctmc(ctmc, file=save_path + 'ctmc', show=False)
print('Computing Steady State and Transition Rate ...')
mypn.init_analysis()
print('Throughput of R1 appointment attend: ')
print(mypn.transition_throughput_rate('T6').iloc[0])
print('Throughput of R2 appointment attend: ')
print(mypn.transition_throughput_rate('T12').iloc[0])
print('Expected # tokens Appointment Request')
print(mypn.expected_number_of_tokens('p.AppointmentRequest').iloc[0])
print('Expected # tokens No Appointment')
print(mypn.expected_number_of_tokens('p.NOT_AppointmentRequest').iloc[0])
print('Expected # tokens R1 Escorting')
print(mypn.expected_number_of_tokens('t.R1EscortVisitor').iloc[0])
print('Expected # tokens R1 Charging')
print(mypn.expected_number_of_tokens('t.R1Charging').iloc[0])
print('Expected # tokens R2 Escorting')
print(mypn.expected_number_of_tokens('t.R2EscortVisitor').iloc[0])
print('Expected # tokens R2 Charging')
print(mypn.expected_number_of_tokens('t.R2Charging').iloc[0])
def random_switch_tune(save_path, draw=False):
'''
Visitor mean wait time as a function of the robot R1
escort speed, the visitors rate and the probability of robot R1 being
assigned, instead of R2, to the escort task.
'''
print('\n\n---- Running random switch tunning example ----')
pntools = gst.GSPNtools()
print('Running Random Switch Tune...')
print('Importing GSPN Model')
mypn = pntools.import_xml('multi_escort_run.xml')[0]
if draw:
drawing = pntools.draw_gspn(mypn,
file=save_path + 'petri_net',
show=False)
list_probs = np.arange(0.1, 1.0, 0.4)
visitors_rates = np.arange(0.1, 10, 1)
robot_speeds = np.arange(0.1, 10, 1)
mean_wait_time = []
for it in tqdm(range(len(list_probs))):
mean_wait_time.append(
np.zeros((len(visitors_rates), len(robot_speeds))))
prob_R1 = list_probs[it]
prob_R2 = 1 - prob_R1
mypn.add_transitions(['T6', 'T12'],
tclass=['exp', 'exp'],
trate=[prob_R1, prob_R2])
for row_i, visitor_r in enumerate(visitors_rates):
mypn.add_transitions(['T13'], tclass=['exp'], trate=[visitor_r])
for column_i, r1_speed in enumerate(robot_speeds):
mypn.add_transitions(['T7'], tclass=['exp'], trate=[r1_speed])
mypn.init_analysis()
mwt = mypn.mean_wait_time('p.AppointmentRequest')
mwt = mwt.iloc[0]
mean_wait_time[it][row_i][column_i] = mwt
print('--------------------------------------------')
print('R1 Prob: ', prob_R1, ' R2 Prob: ', prob_R2)
print('Mean Wait Time: ', mwt)
pickle.dump((visitors_rates, robot_speeds, list_probs, mean_wait_time),
open(save_path + "mean_wait_time.p", "wb"))
def use_xml():
filename = ""
# Get file from user's explorer
# I saved the source for this code in the folder TESE
if request.method == 'POST':
file = request.files['file']
if file.filename == '':
flash('No file selected for uploading')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
else:
flash('Allowed file types are txt, pdf, png, jpg, jpeg, gif')
return redirect(request.url)
tool = gspn_tools.GSPNtools()
gspn = tool.import_xml(filename)[0]
# Begin First Part: add_places
marking = gspn.get_current_marking()
places = []
tokens = []
for place in marking:
places.append(place)
tokens.append(marking[place])
my_pn.add_places(places, tokens)
# Begin Second Part: add_transitions
transitions = gspn.get_transitions()
transition_names = []
transition_types = []
transition_rates = []
for transition in transitions:
transition_names.append(transition)
transition_types.append(transitions[transition][0])
# HEADS UP! THE RATE IS ALWAYS 1
transition_rates.append(1)
my_pn.add_transitions(transition_names, transition_types, transition_rates)
# Begin Third Part: arc_in
arc_in = {}
arc_in_aux = gspn.get_arcs_dict()[0]
for place in arc_in_aux:
place_name = gspn.index_to_places[place]
for transition in arc_in_aux[place]:
if place_name in arc_in:
arc_in[place_name].append(
gspn.index_to_transitions[transition])
else:
arc_in[place_name] = [gspn.index_to_transitions[transition]]
# Begin Fourth Part: arc_out
arc_out = {}
arc_out_aux = gspn.get_arcs_dict()[1]
for transition in arc_out_aux:
transition_name = gspn.index_to_transitions[transition]
for place in arc_out_aux[transition]:
if transition_name in arc_out:
arc_out[transition_name].append(gspn.index_to_places[place])
else:
arc_out[transition_name] = [gspn.index_to_places[place]]
my_pn.add_arcs(arc_in, arc_out)
return render_template("gspn_visualization_home.html", data=my_pn)
def mean_wt_speeds(save_path, draw=False):
'''
Mean wait time of place p.AppointmentRequest as a
function of the firing rates of transitions T7 and T9.
'''
print('\n\n---- Running mean wait time example ----')
pntools = gst.GSPNtools()
print('Importing GSPN Model')
mypn = pntools.import_xml('multi_escort_run.xml')[0]
if draw:
drawing = pntools.draw_gspn(mypn,
file=save_path + 'petri_net',
show=False)
min_escort_rate = 0.1
max_escort_rate = 10
escort_rates = np.arange(min_escort_rate, max_escort_rate, 0.1)
mean_wait_time = []
bat_trans_rates = []
for escort_trans_rate in escort_rates:
# function that defines how the battery discharge rate ('T9') varies as a function of the robot speed ('T7')
bat_trans_rate = math.pow(escort_trans_rate - 5, 2)
bat_trans_rates.append(bat_trans_rate)
# set the transitions firing rate
mypn.add_transitions(['T7', 'T9'],
tclass=['exp', 'exp'],
trate=[escort_trans_rate, bat_trans_rate])
mypn.init_analysis()
mwt = mypn.mean_wait_time('p.AppointmentRequest')
mwt = mwt.iloc[0]
mean_wait_time.append(mwt)
print('Mean Wait Time: ', mwt)
transitions = mypn.get_transitions()
print(np.shape(escort_rates))
print('Escort Rates: ', list(escort_rates))
print(np.shape(bat_trans_rates))
print('Bat discharge rates: ', bat_trans_rates)
print(np.shape(mean_wait_time))
print('Mean wait time: ', mean_wait_time)
sns.set()
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot3D(escort_rates, bat_trans_rates, mean_wait_time)
# ax.scatter3D(escort_rates, bat_trans_rates, mean_wait_time)
ax.set_xlabel('T7 Firing Rate')
ax.set_ylabel('T9 Firing Rate')
ax.set_zlabel('\nMean Wait Time Visitor \n (p.AppointmentRequest)')
# plt.show()
fig.savefig(save_path + 'mean_wait_time.pdf')
def check_wait_time(save_path):
'''
The mean wait time of the place p.AppointmentRequest
as a function of the number of robots.
'''
print(
'\n\n---- Running mean wait time as a function of number of robots example ----'
)
pntools = gst.GSPNtools()
print('Importing GSPN Model')
mypn = pntools.import_xml('rvary_escort_run.xml')[0]
n_robots = []
mean_wt = []
# Get base gspn
base_tr = mypn.get_transitions()
base_pl = mypn.get_current_marking()
base_arc_in, base_arc_out = mypn.get_arcs_dict()
mypn.add_places(['p.AppointmentRequest', 'p.NOT_AppointmentRequest'],
[0, 1],
set_initial_marking=True)
mypn.add_transitions(['T100'], ['exp'], [10])
arc_in = {}
arc_in['p.NOT_AppointmentRequest'] = ['T100']
arc_out = {}
arc_out['T100'] = ['p.AppointmentRequest']
mypn.add_arcs(arc_in, arc_out)
arc_in = {}
arc_in['p.AppointmentRequest'] = ['T6']
arc_out = {}
arc_out['T6'] = ['p.NOT_AppointmentRequest']
mypn.add_arcs(arc_in, arc_out)
mypn.init_analysis()
mwt = mypn.mean_wait_time('p.AppointmentRequest')
mwt = mwt.iloc[0]
print('--------------------------------------------')
print('# Robots: ', 1)
print('Mean Wait Time: ', mwt)
n_robots.append(1)
mean_wt.append(mwt)
n_extra_robots = 4
for robot_i in tqdm(range(n_extra_robots)):
new_tr = {k + str(robot_i): v for k, v in base_tr.items()}
new_pl = {k + str(robot_i): v for k, v in base_pl.items()}
new_arc_in = {
k + str(robot_i): [s + str(robot_i) for s in v]
for k, v in base_arc_in.items()
}
new_arc_out = {
k + str(robot_i): [s + str(robot_i) for s in v]
for k, v in base_arc_out.items()
}
mypn.add_transitions_dict(new_tr)
mypn.add_places_dict(new_pl, set_initial_marking=True)
mypn.add_arcs(new_arc_in, new_arc_out)
arc_in = {}
arc_in['p.AppointmentRequest'] = ['T6' + str(robot_i)]
arc_out = {}
arc_out['T6' + str(robot_i)] = ['p.NOT_AppointmentRequest']
mypn.add_arcs(arc_in, arc_out)
mypn.init_analysis()
mwt = mypn.mean_wait_time('p.AppointmentRequest')
mwt = mwt.iloc[0]
print('--------------------------------------------')
print('# Robots: ', robot_i + 2)
print('Mean Wait Time: ', mwt)
n_robots.append(robot_i + 2)
mean_wt.append(mwt)
pickle.dump((n_robots, mean_wt), open(save_path + "wait_n_robots.p", "wb"))
def transient_evol(save_path, draw=False):
'''
Transient evolution of the probability of the robot being
available as a function of time, obtained for two scenarios:
1) a set of batteries cheaper with low performance (slow charge, quick discharge);
2) a set of batteries more expensive with higher performance (quick charge, slow discharge);
'''
print('\n\n---- Running transient evolution example ----')
pntools = gst.GSPNtools()
print('Importing GSPN Model')
mypn = pntools.import_xml('multi_escort_run.xml')[0]
if draw:
drawing = pntools.draw_gspn(mypn,
file=save_path + 'petri_net',
show=False)
print('Generating CT')
ct_tree = gspn_analysis.CoverabilityTree(mypn)
ct_tree.generate()
print('Bounded? : ', ct_tree.boundedness())
if draw:
pntools.draw_coverability_tree(ct_tree,
file=save_path + 'cv_tree',
show=False)
print('Generating CTMC')
ctmc = gspn_analysis.CTMC(ct_tree)
ctmc.generate()
if draw:
pntools.draw_ctmc(ctmc, file=save_path + 'ctmc', show=False)
uni_dist = pd.DataFrame(1.0 / len(ctmc.state) * np.ones(len(ctmc.state)))
uni_dist.index = ctmc.state
states = ctmc.state.keys()
states = sorted(states)
# get the states where the place 'p.R1Available' has 1 token
# means that robot R1 is available
enabled_states = []
for state_name in states:
marking = ctmc.state[state_name][0]
if ['p.R1Available', 1] in marking:
enabled_states.append(state_name)
# Quick battery charging/Slow discharge
discharge_rate = 0.1
charging_rate = 1.0
# set the transitions firing rate
mypn.add_transitions(['T3', 'T2'],
tclass=['exp', 'exp'],
trate=[discharge_rate, charging_rate])
mypn.init_analysis()
step = 0.1
time_window = 50
prob_available = []
prob_sum = np.zeros(int(time_window / step))
for state in enabled_states:
print('Computing transition evolution for state: ', state)
prob_avlbl = mypn.transition_probability_evolution(
time_window, step, uni_dist, state)
prob_sum += prob_avlbl
prob_available.append(prob_avlbl)
sns.set()
fig = plt.figure()
t = np.arange(0, time_window, step)
plt_pt1 = plt.plot(t,
prob_sum,
label='Quick battery charging/Slow discharge')
# Slow battery charging/Quick discharge
discharge_rate = 1.0
charging_rate = 0.1
# set the transitions firing rate
mypn.add_transitions(['T3', 'T2'],
tclass=['exp', 'exp'],
trate=[discharge_rate, charging_rate])
mypn.init_analysis()
prob_available = []
prob_sum = np.zeros(int(time_window / step))
for state in enabled_states:
print('Computing transition evolution for state: ', state)
prob_avlbl = mypn.transition_probability_evolution(
time_window, step, uni_dist, state)
prob_sum += prob_avlbl
prob_available.append(prob_avlbl)
plt_pt2 = plt.plot(t,
prob_sum,
label='Slow battery charging/Quick discharge')
plt.xlabel("Time [s]")
plt.ylabel("Probability of robot 1 being available")
plt.legend(loc='lower right')
# plt.show()
plt_pt1.savefig(save_path + 'prob_available_new.pdf')