def make_weighted_supervisor(comp_name, req_name, sup_name): """ Compute a weighted supervisor. @param comp_name: Available component (weighted automaton). @type comp_name: C{str} @param req_name: Available requirement (unweighted automaton). @type req_name: C{str} @param sup_name: Name of resulting supervisor (unweighted automaton). @type sup_name: C{str} """ common.print_line("Started weighted supervisor computation " "(version %s)" % automata.version) coll = collection.Collection() comp = load_weighted_automaton(coll, comp_name, False, True) req = frontend.load_automaton(coll, req_name, False, True) sup = weighted_supervisor.compute_weighted_supervisor(comp, req) if sup is None: common.print_line("Weighted supervisor cannot be computed.") return else: frontend.dump_stats("Computed weighted supervisor", sup) frontend.save_automaton(sup, "Supervisor is saved in %s\n", sup_name)
def make_time_optimal_supervisor(comp_names, req_names, evt_pairs, sup_name): """ Compute a time optimal supervisor. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of C{str} @param req_names: Available requirements (unweighted automata). @type req_names: C{List} of C{str} @param evt_pairs: Additional event pairs (eg "{(a, b), (c, e)}", "type1", or "type2") @type evt_pairs: C{str} @param sup_name: Name of resulting supervisor (unweighted automaton). @type sup_name: C{str} """ common.print_line("Started time optimal supervisor computations " "(version %s)" % automata.version) coll = collection.Collection() comp_list = load_weighted_automata(coll, comp_names, False, True) req_list = frontend.load_automata(coll, req_names, False, True) evt_pairs = taskresource.process_event_pairs(coll, req_list, evt_pairs) result = compute_weight.compute_time_optimal_supervisor( comp_list, req_list, evt_pairs) if result is None: common.print_line("Time optimal supervisor cannot be computed.") return else: sup, min_weight = result common.print_line("Minimum makespan is %d" % min_weight) frontend.dump_stats("Computed time optimal supervisor", sup) frontend.save_automaton(sup, "Supervisor is saved in %s\n", sup_name)
def make_minimal_weighted_supervisor(plant, req, new_fname): """ Compute deterministic weighted supervisor for non-deterministic plant and deterministic requirements. @param plant: Filename of the non-deterministic weighted (but not minimally) automaton. @type plant: C{str} @param req: Filename of the requirements as deterministic non-weighted automaton. @type req: C{str} @param new_fname: Filename of the created deterministic controller. @type new_fname: C{str} """ common.print_line("Started minimal weighted supervisor computations " "(version %s)" % automata.version) coll = collection.Collection() plant_waut = load_weighted_automaton(coll, plant, False, True) req_aut = frontend.load_automaton(coll, req, False, True) wsup = compute_weight.compute_weighted_supremal(plant_waut, req_aut) if wsup is None: new_aut = None else: observables = set( [evt for evt in plant.events.itervalues() if evt.observable]) check_marking_aware(wsup, observables) wsup2 = weighted_projection.weighted_projection(wsup, observables) new_aut = compute_weight.minimal_weight_deterministic_controllable( wsup2) if new_aut is None: common.print_line("No minimal weight controller found!") else: unw_plant = conversion.remove_weights(plant_waut) prod = product.n_ary_unweighted_product([unw_plant, new_aut[0]]) result = supervisor.unweighted_determinization(prod) common.print_line("Minimum weight is %s" % new_aut[1]) frontend.save_automaton(result, "Saving minimal weight controller in %s", new_fname)
def make_remove_weighted(waut_fname, result_fname): """ Remove the weights of weighted automaton L{waut_fname}, and write the result to L{result_fname}. @param waut_fname: Filename of weighted automaton to load. @type waut_fname: C{str} @param result_fname: Filename of the resulting unweighted automaton. @type result_fname: C{str} """ common.print_line("Started removing weights (version %s)" % automata.version) coll = collection.Collection() waut = load_weighted_automaton(coll, waut_fname, False, False) aut = conversion.remove_weights(waut) frontend.save_automaton(aut, "Result is saved in %s\n", result_fname)
def process_system(automata, output_dir, explicitly_disable, cranes): #explicitly_disable = False if not os.path.exists(output_dir + "\\before_removal\\"): os.makedirs(output_dir + "\\before_removal\\") for aut in automata: aut.save_as_dot(output_dir + "\\before_removal\\" + aut.name + ".dot") remove_always_disabled_events(automata) if not os.path.exists(output_dir + "\\after_removal\\"): os.makedirs(output_dir + "\\after_removal\\") for aut in automata: print aut.name aut.save_as_dot(output_dir + "\\after_removal\\" + aut.name + ".dot") tick = automata[0].collection.make_event("tick", True, True, False) tau = automata[0].collection.make_event("tau", False, False, False) #automata.append(make_move_order([aut for aut in automata if aut.name.startswith("SC")], \ # automata[0].collection, "move_order")) #remove_always_disabled_events(automata) #for i, aut in enumerate(automata): # if aut.name.startswith("D"): # move_events = [aut.collection.events[evt] for evt in aut.collection.events if "mov" in evt and evt[1] == aut.name[1]] # add_move_events_to_crane(aut, move_events) # aut.alphabet.add(tau) # automata[i] = tau_abstraction.convert_weighted_to_tick(aut, tick) #if explicitly_disable: # for aut in automata: # if aut.name.startswith("CS"): # explicitly_disable_events(aut, cranes, int(aut.name[2:])) #if explicitly_disable: # evts = set() # for aut in automata: # if aut.name.startswith("SC"): # evts.update(aut.alphabet) # for aut in list(automata): # if aut.name.startswith("CS"): # explicitly_disable_events2(aut, cranes, evts) #for i, aut in enumerate(automata): # if aut.name.startswith("CS"): # aut.alphabet.add(tau) # automata[i] = tau_abstraction.convert_weighted_to_tick(aut, tick) sc_order = output_crane_order(automata, output_dir) #sc_order = output_crane_order_track_first(automata, output_dir) if explicitly_disable: for i, aut in enumerate(sc_order): print aut.name explicitly_disable_events_container(aut, cranes, sc_order[i+1:]) if not os.path.exists(output_dir + "\\after_disable\\"): os.makedirs(output_dir + "\\after_disable\\") for aut in automata: aut.save_as_dot(output_dir + "\\after_disable\\" + aut.name + ".dot") if not os.path.exists(output_dir + "\\weighted\\"): os.makedirs(output_dir + "\\weighted\\") if not os.path.exists(output_dir + "\\unweighted\\"): os.makedirs(output_dir + "\\unweighted\\") if not os.path.exists(output_dir + "\\unweightedtau\\"): os.makedirs(output_dir + "\\unweightedtau\\") for aut in automata: save_weighted_automaton(aut, "", output_dir + "\\weighted\\" + aut.name + ".cfg") save_automaton(aut, "", output_dir + "\\unweighted\\" + aut.name + ".cfg") new_init = aut.add_new_state(False) aut.alphabet.add(tau) aut.add_edge_data(new_init, aut.initial, tau, 1) aut.initial = new_init save_automaton(aut, "", output_dir + "\\unweightedtau\\" + aut.name + ".cfg") string_unweighted = "\"C:\Users\sware\swareaug12\\aug5\Latest version2\Latest version\make_aggregated_supervisor.py\" -d " string_weighted = "\"C:\Users\sware\swareaug12\\aug5\Latest version2\Latest version\make_tau_abstracted_supervisor.py\" -d " for i, aut in enumerate(automata): if i != 0: string_unweighted += "," string_weighted += "," string_unweighted += aut.name + ".cfg" string_weighted += aut.name + ".cfg" string_unweighted += " req.cfg " string_weighted += " req.cfg {} sup.cfg" handle = file(output_dir + "\\unweighted\\cranetau.bat", 'w') handle.write(string_unweighted + " steps") handle.close() handle = file(output_dir + "\\unweightedtau\\cranetau.bat", 'w') handle.write(string_unweighted + " steps") handle.close() handle = file(output_dir + "\\unweighted\\cranetau_full_track.bat", 'w') handle.write(string_unweighted + " steps_full_track") handle.close() handle = file(output_dir + "\\unweighted\\cranetau_segments.bat", 'w') handle.write(string_unweighted + " steps_segments") handle.close() handle = file(output_dir + "\\weighted\\cranetau.bat", 'w') handle.write(string_unweighted) handle.close() #output_crane_order(automata, output_dir) output_crane_order_compose_segments(automata, output_dir) output_crane_order_compose_full_track(automata, output_dir)
eventlist = [] pathstate = path.initial while not pathstate.marked: for edge in pathstate.get_outgoing(): pathstate = edge.succ eventlist.append(edge.label) return eventlist common.print_line("Calculating product...") path_found = False plant = heap_unfold_product(comp_list, eventdata, heap_len, distances_to_marker, shortest_path) if path_found: plant.reduce(True, True) common.print_line("Path found, outputting to file...") plant.save_as_dot("test_plant_as_dot.dot") frontend.save_automaton(plant, "saving", "epuckpath.cfg") trace = extract_trace(plant) string = "" for (i, event) in enumerate(trace): if i != 0: string += ", " string += event.name handle = file("epuckevents.txt", 'w') handle.write(string) handle.close() else: common.print_line("No path could be found...")