def make_interval_product(aut_names, productname): coll = collection.Collection() auts = load_interval_automata(collection.Collection(), aut_names, False, True) product = IntervalSynchronousProduct(auts, coll) saver = IntervalAutomatonSaver() product.save_as_dot("C.dot") saver.save(product, productname)
def make_weighted_projection(aut_name, evt_names, result_fname): """ Perform projection over a weighted automaton. @param aut_name: Filename of the automaton to project. @type aut_name: L{WeightedAutomaton} @param evt_names: Comma seperated list of event names to preserve. @type evt_names: C{str} @param result_fname: Filename for writing the resulting weighted automaton. @type result_fname: C{str} """ common.print_line("Started weighted projection computation (version %s)" % automata.version) coll = collection.Collection() waut = load_weighted_automaton(coll, aut_name, False, False) events = frontend.get_events(coll, evt_names) waut2 = weighted_projection.weighted_projection(waut, events) frontend.dump_stats("Computed weighted projection", waut2) save_weighted_automaton(waut2, "Projected automaton is saved in %s", result_fname)
def load_test_mult_supervisors(plant_list, supervisors, evt_pairs, comp_mut_ex): coll = collection.Collection() plant_list = weighted_frontend.load_weighted_automata( coll, plant_list, False, True) events = coll.events C1_events = set([events[evt] for evt in events if evt.startswith("C1")]) C2_events = set([events[evt] for evt in events if evt.startswith("C2")]) C3_events = set([events[evt] for evt in events if evt.startswith("C3")]) plant_list = [] aut = weighted_structure.WeightedAutomaton(C1_events, coll) aut.initial = aut.add_new_state(True, 0) for evt in C1_events: aut.add_edge_data(aut.initial, aut.initial, evt, 1) plant_list.append(aut) aut = weighted_structure.WeightedAutomaton(C2_events, coll) aut.initial = aut.add_new_state(True, 0) for evt in C2_events: aut.add_edge_data(aut.initial, aut.initial, evt, 1) plant_list.append(aut) aut = weighted_structure.WeightedAutomaton(C3_events, coll) aut.initial = aut.add_new_state(True, 0) for evt in C3_events: aut.add_edge_data(aut.initial, aut.initial, evt, 1) plant_list.append(aut) result = taskresource.compute_custom_eventdata_extended( plant_list, evt_pairs, comp_mut_ex) supervisors = frontend.load_automata(coll, supervisors, False, True) #tau_abstraction.testpath_not_weighted(plant_list, supervisors[0], None) eventdata, cliques = result for event in eventdata: eventdata[event].matHat = maxplus.matrix_to_vector( eventdata[event].matHat) calcpath_mult(supervisors, eventdata, len(cliques))
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_nonconflicting_check(aut_fnames, use_heuristic): """ Verify whether the automata do not conflict with each other. @param aut_fnames: Comma-seperated list of automata filenames. @type aut_fnames: C{str} @param use_heuristic: Compute a smart order for the automata (rather than use the supplied order). @type use_heuristic: C{str} @return: Indication that no conflict has been found (all is ok). @rtype: C{bool} """ common.print_line("Started nonconflicting check (version %s)" % automata.version) coll = collection.Collection() auts = load_automata(coll, aut_fnames, False, False) if parse_boolean(use_heuristic): auts = abstraction.order_automata(auts) # else, user has supplied the automata in the right order. result = abstraction.nonconflicting_check(auts) if result: print "nonconflicting_check: HOLDS" else: print "nonconflicting_check: CONFLICT FOUND" return result
def make_natural_projection(aut_name, evt_names, result_fname): """ Perform projection over a language. @param aut_name: Filename of the automaton to project. @type aut_name: L{Automaton} @param evt_names: Comma seperated list of event names to preserve. @type evt_names: C{str} @param result_fname: Filename for writing the resulting automaton. @type result_fname: C{str} """ common.print_line("Started natural projection computation (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_name, False, False) events = get_events(coll, evt_names) aut2 = supervisor.unweighted_determinization(aut) result = supervisor.natural_projection_map(aut2, events)[0] dump_stats("Computed projection", result) save_automaton(result, "Projected automaton is saved in %s", result_fname)
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_observer_check(aut_name, evt_names): """ Perform observer_check of the automaton stored in L{aut_name}. @param aut_name: Filename of the automaton to abstract. @type aut_name: L{Automaton} @param evt_names: Comma seperated list of event names to preserve. @type evt_names: C{str} """ common.print_line("Started observer-check computation (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_name, True, False) events = get_events(coll, evt_names) bad_events = abstraction.observer_check(aut, events) if len(bad_events) == 0: common.print_line("Observer-check property HOLDS") else: if len(bad_events) == 1: evt_text = "event" else: evt_text = "events" evts = ", ".join(event.name for event in bad_events) common.print_line("Observer-check property does not hold " "due to %s %s" % (evt_text, evts))
def make_sequential_abstraction(aut_fnames, evt_names, result_fname): """ Perform sequential abstraction on a number of automata. @param aut_fnames: Comma-seperated list of automata filenames. @type aut_fnames: C{str} @param evt_names: Comma seperated list of event names. @type evt_names: C{str} @param result_fname: Filename for writing the resulting automaton. @type result_fname: C{str} """ common.print_line("Started sequential abstraction computations " "(version %s)" % automata.version) coll = collection.Collection() auts = load_automata(coll, aut_fnames, True, False) auts = abstraction.order_automata(auts) events = get_events(coll, evt_names) events = ensure_tau(coll, events) result = abstraction.sequential_abstraction(auts, events) save_automaton(result, "Abstraction is saved in %s", result_fname)
def generate_task_resource_use(comp_names, req_names, text_path, plots, usefname): """ Generate a task/resource usage picture for path L{text_path} with components L{comp_names} and requirements L{req_names}. Output data in L{usefname}. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of L{str} @param req_names: Available requirements (unweighted automata). @type req_names: C{list} of L{str} @param text_path: Sequence of events on the path (a sequence of event names, comma or white-space seperated). @type text_path: C{string} @param plots: Names of automata to plot, if specified. @type plots: C{str} @param usefname: Filename for writing task/resource use to. @type usefname: C{str} @note: The L{comp_names} and L{req_names} are only used to compute the shape of the pieces at the heap. Therefore, for type 1 requirements (where the requirements automata are not used in that calculation), L{req_names} should be left empty. """ common.print_line('Started generation of task/resource use (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) plots = set(plots.replace(',', ' ').split()) if plots: # Non-empty set. plot_auts = set(aut for aut in comp_list + req_list if aut.name in plots) else: plot_auts = None # All automata should be plotted. uses = compute_weight.generate_task_resource_use(comp_list, req_list, plot_auts, text_path) if usefname: handle = open(usefname, 'w') for use in uses: handle.write('%s\t%s\t%s\t%s\n' % use) handle.close() else: for use in uses: print '%s\t%s\t%s\t%s' % use
def make_greedy_time_optimal_supervisor_row_vectors(comp_names, req_names, evt_pairs, sup_name, row_vectors, operator): """ Compute a greedy time optimal supervisor. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of L{str} @param req_names: Available requirements (unweighted automata). @type req_names: C{list} of L{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 the resulting supervisor. @type sup_name: C{str} """ common.print_line("Started greedy time optimal supervisor " "computation (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 = taskresource.compute_custom_eventdata(comp_list, evt_pairs) if result is None: common.print_line('Could not compute the event data from the ' 'components and event pairs\n' 'Perhaps they are inconsistent?') return eventdata, heap_len = result result = compute_weight.compute_greedy_time_optimal_supervisor( comp_list, req_list, eventdata, heap_len, row_vectors, operator) if result is None: common.print_line('Could not compute the weighted supervisor') return wsup, wmap = result one = maxplus.make_rowmat(0, heap_len) one = maxplus.otimes_mat_mat(one, wmap[wsup.initial]) biggest = one.get_scalar() common.print_line("Sub-optimal makespan is %s" % biggest) wsup = weighted_supervisor.reduce_automaton_row_vecors( wsup, wmap, eventdata, heap_len, row_vectors) frontend.dump_stats("Computed weighted supervisor", wsup) save_weighted_automaton(wsup, "Supervisor is saved in %s\n", sup_name)
def make_get_weighted_size(aut_fname): """ Display size of the weighted automaton. @param aut_fname: Filename of the weighted automaton. @type aut_fname: C{str} """ common.print_line("Started calculating size (version %s)" % automata.version) coll = collection.Collection() aut = load_weighted_automaton(coll, aut_fname, False, False) print str(aut)
def convert_from_ads(ads_fname, aut_fname): """ Convert ADS file to own automaton file format. @param ads_fname: Filename of the ADS file to load. @type ads_fname: C{str} @param aut_fname: Output filename for the converted automaton. @type aut_fname: C{str} """ coll = collection.Collection() aut = read_ads.convert_ads_file(ads_fname, coll) dump_stats("Converted automaton", aut) save_automaton(aut, "Automaton is saved in %s", aut_fname)
def make_trim(aut_fname, out_fname): """ Trim the automaton L{aut} (reduce to reachable and co-reachable states). @param aut_fname: Filename of the automaton. @type aut_fname: C{str} @param out_fname: Filename of the resulting automaton. @type out_fname: C{str} """ common.print_line("Started trimming (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_fname, False, False) aut.reduce(True, True) dump_stats("Computed result", aut) save_automaton(aut, "Result is saved in %s\n", out_fname)
def make_remove_tau_event(aut_fname, out_fname): """ Remove 'tau' event from the automaton. May fail. @param aut_fname: Filename of the automaton. @type aut_fname: C{str} @param out_fname: Filename of the resulting automaton. @type out_fname: C{str} """ common.print_line("Started removing 'tau' event (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_fname, False, False) abstraction.remove_tau(aut) # Does in-place modification. dump_stats("Computed result", aut) save_automaton(aut, "Result is saved in %s\n", out_fname)
def make_add_tau_event(aut_fname, out_fname): """ Add 'tau' event to the automaton. @param aut_fname: Filename of the automaton. @type aut_fname: C{str} @param out_fname: Filename of the resulting automaton. @type out_fname: C{str} """ common.print_line("Started adding 'tau' event (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_fname, False, False) aut = abstraction.add_tau_event(aut) dump_stats("Computed result", aut) save_automaton(aut, "Result is saved in %s\n", out_fname)
def make_weighted_dot(aut_fname, dot_fname): """ Convert automaton to Graphviz format. @param aut_fname: Filename of the automaton to convert. @type aut_fname: C{str} @param dot_fname: Output filename for the Graphviz data. @type dot_fname: C{str} """ coll = collection.Collection() aut = load_weighted_automaton(coll, aut_fname, False, False) frontend.make_backup_file(dot_fname) dot_handle = open(dot_fname, 'w') dot_handle.write(aut.to_dot()) dot_handle.close()
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_reset_weighted(aut_fname, result_fname): """ Reset the weights in weighted automaton L{aut_fname} to 0, and write the result to L{result_fname}. @param aut_fname: Filename of weighted automaton to load. @type aut_fname: C{str} @param result_fname: Filename for writing the resulting weighted automaton. @type result_fname: C{str} """ common.print_line("Started resetting weights (version %s)" % automata.version) coll = collection.Collection() aut = load_weighted_automaton(coll, aut_fname, False, False) aut.reset_weight(0) save_weighted_automaton(aut, "Result is saved in %s\n", result_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 make_unweight_time_optimal_supervisor(comp_names, req_names, evt_pairs, sup_name): """ Compute a non weighted time optimal supervisor. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of L{str} @param req_names: Available requirements (unweighted automata). @type req_names: C{list} of L{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 the resulting supervisor. @type sup_name: C{str} """ common.print_line("Started time unweight optimal supervisor computations " "(version %s)" % automata.version) coll = collection.Collection() comp_list = load_unweight_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_unweight_time_optimal_supervisor( comp_list, req_list, evt_pairs) if result is None: common.print_line('Could not compute the weighted supervisor') return wsup = result #one = maxplus.make_rowmat(0, heap_len) #one = maxplus.otimes_mat_mat(one, wmap[wsup.initial]) #biggest = one.get_scalar() #common.print_line("Sub-optimal makespan is %s" % biggest) #wsup = weighted_supervisor.reduce_automaton(wsup, wmap, eventdata, # heap_len) frontend.dump_stats("Computed unweighted supervisor", wsup) save_weighted_automaton(wsup, "Supervisor is saved in %s\n", sup_name)
def make_minimized(aut_name, result_fname): """ Perform minimization of the automaton stored in L{aut_name}, and write the result to L{result_fname}. @param aut_name: Filename of the automaton to. @type aut_name: L{Automaton} @param result_fname: Filename for writing the resulting automaton. @type result_fname: C{str} """ common.print_line("Started minimization computation (version %s)" % automata.version) coll = collection.Collection() aut = load_automaton(coll, aut_name, False, False) result = abstraction.abstraction(aut, aut.alphabet) dump_stats("Computed minimized result", result) save_automaton(result, "Minimized automaton is saved in %s", result_fname)
def make_controllability_check(plant_fname, sup_fname): """ Verify whether the plant is controllable with the supervisor. @param plant_fname: Filename of the plant automaton. @type plant_fname: C{str} @param sup_fname: Filename of the supervisor. @type sup_fname: C{str} """ common.print_line("Started controllability check (version %s)" % automata.version) coll = collection.Collection() sup_aut = load_automaton(coll, sup_fname, False, False) plant_aut = load_automaton(coll, plant_fname, False, False) contr_disableds, uncontr_disableds = \ find_disabled_events(sup_aut, plant_aut) if len(contr_disableds) > 0: print "States with disabled controllable events:" for sup_s, plant_s, dis_e in contr_disableds: print " (%d, %d): {%s}" % (plant_s.number, sup_s.number, ", ".join([e.name for e in dis_e])) print if len(uncontr_disableds) > 0: print "States with disabled uncontrollable events:" for sup_s, plant_s, dis_e, sup_p, plant_p in uncontr_disableds: print " (%d, %d): {%s}" % (plant_s.number, sup_s.number, ", ".join([e.name for e in dis_e])) print " Supervisor path: " + make_path_string(sup_p) print " Plant path: " + make_path_string(plant_p) print print "Supervisor is INCORRECT (has disabled uncontrollable events)" sys.exit(1) else: print "Supervisor is correct (no disabled uncontrollable events)"
def create_local_automaton(aut, local_alphabet, start_state, end_state): # creating temporary automaton temp_coll = collection.Collection() temp_automaton = weighted_structure.WeightedAutomaton( local_alphabet, temp_coll) for state in aut.get_states(): ns = temp_automaton.add_new_state(state == end_state, state.number) for state in aut.get_states(): for edge in state.get_outgoing(): if edge.label in local_alphabet: new_edge = edge.copy( temp_automaton.get_state(edge.pred.number), temp_automaton.get_state(edge.succ.number)) temp_automaton.add_edge(new_edge) temp_automaton.initial = temp_automaton.get_state(start_state.number) temp_automaton.reduce(True, True) if temp_automaton.get_num_states() == 0: return None else: return temp_automaton
def make_weighted_product(aut_fnames, result_fname): """ Multiply the weighthed automata in the L{aut_fnames} list, and write the result to L{result_fname}. @param aut_fnames: Comma-seperated list of weighted automata filenames. @type aut_fnames: C{str} @param result_fname: Filename for writing the resulting weighted automaton. @type result_fname: C{str} """ common.print_line("Started weighted product computations (version %s)" % automata.version) coll = collection.Collection() aut_list = load_weighted_automata(coll, aut_fnames, False, False) result = weighted_product.n_ary_weighted_product( aut_list, algorithm.SUM_EDGE_WEIGHTS, True, True) frontend.dump_stats("Computed product", result) save_weighted_automaton(result, "Product is saved in %s\n", result_fname)
def make_system2(num_cranes, num_slots, init_crane, num_containers): filenames = [] coll = collection.Collection() automata = [] for i in range(1, num_cranes + 1): stnum = str(i) name = "D" + stnum filenames.append(name) automata.append(make_crane(i, num_slots, num_containers, coll, name)) defaultinit = "1" craneslot = {} inits = {} for (crane, slot) in init_crane: inits[slot] = str(crane + 1) craneslot[crane] = slot for i in range(1, num_slots + 1): stnum = str(i).zfill(3) name = "CS" + stnum filenames.append(name) init = defaultinit if i not in inits else inits[i] automata.append(make_crane_location(num_cranes, i, num_containers, i == num_slots, init, coll, name)) for i in range(1, num_slots): for c in range(1, num_cranes + 1): crane = "C" + str(c) name = "E" + str(c) + "_" + str(i).zfill(3) filenames.append(name) init = 1 if craneslot[c] <= i else 2 automata.append(make_crane_restriction(crane, i, init, coll, name)) picks = generate_containers4(num_containers, num_slots) num = 0 for pick in picks: drops = picks[pick] for i in range(len(drops)): drop, num = drops[i] num += 1 stnum = str(num) name = "SC" + stnum filenames.append(name) automata.append(make_container(num, pick, drop, None, num_cranes, num_slots, coll, name)) process_system(automata, "cranes", True, num_cranes)
def row_vector_compute(plant, req_names, evt_pairs, row_vector_names, operator_class): coll = collection.Collection() comp_list = weighted_frontend.load_weighted_automata( coll, plant, False, True) req_list = frontend.load_automata(coll, req_names, False, True) evt_pairs = taskresource.process_event_pairs(coll, req_list, evt_pairs) result = taskresource.compute_custom_eventdata(comp_list, evt_pairs) if result is None: common.print_line('Could not compute the event data from the ' 'components and event pairs\n' 'Perhaps they are inconsistent?') return eventdata, heap_len = result plant = weighted_product.n_ary_weighted_product( comp_list, algorithm.EQUAL_WEIGHT_EDGES) requirement = product.n_ary_unweighted_product(req_list) for comp in comp_list: comp.clear() del comp_list wsup = compute_weight.compute_weighted_supremal(plant, requirement) if wsup is None: return None requirement.clear() del requirement row_zero_mat = maxplus.make_rowmat(0, heap_len) row_epsilon_mat = maxplus.make_rowmat(maxplus.INFINITE, heap_len) marker_valfn = lambda state: row_zero_mat nonmarker_valfn = lambda state: row_epsilon_mat row_vecs = compute_state_row_vector(wsup, marker_valfn, nonmarker_valfn, eventdata, operator_class) return row_vecs
def make_supervisor(plant_fnames, spec_fnames, sup_fname): """ Construct a supervisor for controlling a plant within its specification. Function aborts if supervisor construction fails. @param plant_fnames: Filenames of the plant automata. @type plant_fnames: C{str} @param spec_fnames: Filenames of the specification automata. @type spec_fnames: C{str} @param sup_fname: Filename for the resulting supervisor. @type sup_fname: C{str} @todo: Supervisor computation should set the automaton kind by itself. """ common.print_line("Started supervisor computations (version %s)" % automata.version) coll = collection.Collection() plants = load_automata(coll, plant_fnames, False, True) specs = load_automata(coll, spec_fnames, False, True) sup = supervisor.make_supervisor(plants, specs) if sup is None: print "Supervisor is empty" sys.exit(1) else: # FIXME: This is the wrong place for setting the result kind npl = sum(1 for plant in plants if plant.aut_kind == 'plant') nsp = sum(1 for spec in specs if spec.aut_kind == 'requirement') if npl == len(plants) and nsp == len(specs): if sup.aut_kind == 'unknown': sup.set_kind('supervisor') dump_stats("Computed supervisor", sup) save_automaton(sup, "Supervisor saved in %s", sup_fname)
def compute_shortest_path(comp_names, req_names, evt_pairs): """ Compute shortest path with A* algorithm and type 1 requirements. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of L{str} @param req_names: Name of the requirement automata (unweighted automata). @type req_names: C{list} of L{str} @param evt_pairs: Additional event pairs (eg "{(a, b), (c, e)}", "type1", or "type2") @type evt_pairs: C{str} """ common.print_line('Started shortest path type 1 computation (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) compute_weight.compute_shortest_path(comp_list, req_list, evt_pairs)
def FK_row_vector(comp_names, req_names, evt_pairs): """ Compute a LBE greedy time optimal supervisor. @param comp_names: Available components (weighted automata). @type comp_names: C{list} of L{str} @param req_names: Available requirements (unweighted automata). @type req_names: C{list} of L{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 the resulting supervisor. @type sup_name: C{str} """ common.print_line("Started greedy time optimal supervisor " "computation (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 = taskresource.compute_custom_eventdata(comp_list, evt_pairs) if result is None: common.print_line('Could not compute the event data from the ' 'components and event pairs\n' 'Perhaps they are inconsistent?') return eventdata, heap_len = result result = compute_weight.FK_row_vector(comp_list, req_list, eventdata, heap_len) if result is None: common.print_line('Could not compute the row vector') return