示例#1
0
    def realize_to_controller(self):
        """Realize the goal into a Controller object"""

        if self.controller is not None:
            return

        if self.session_name is None:
            folder_name = f"{self.s_controller_folder_name}/{self.goal_folder_name}"
        else:
            folder_name = f"{self.session_name}/{self.s_controller_folder_name}/{self.goal_folder_name}"

        try:
            controller_info = self.specification.get_controller_info()
            a, g, i, o = controller_info.get_strix_inputs()
            controller_synthesis_input = StringMng.get_controller_synthesis_str(
                controller_info)
            Store.save_to_file(controller_synthesis_input, "controller.txt",
                               folder_name)
            realized, kiss_mealy, time = Strix.generate_controller(a, g, i, o)

            if not realized:
                controller_info = self.specification.get_controller_info(
                    world_ts=self.__world.typeset)
                a, g, i, o = controller_info.get_strix_inputs()
                controller_synthesis_input = StringMng.get_controller_synthesis_str(
                    controller_info)
                Store.save_to_file(controller_synthesis_input,
                                   "controller.txt", folder_name)
                realized, kiss_mealy, time = Strix.generate_controller(
                    a, g, i, o)

            self.__realizable = realized

            if realized:
                Store.save_to_file(kiss_mealy, "controller_kiss", folder_name)
                # Store.generate_eps_from_dot(dot_mealy, "controller", folder_name)
            else:
                Store.save_to_file(kiss_mealy, "controller_inverted_kiss",
                                   folder_name)
                # Store.generate_eps_from_dot(dot_mealy, "controller_inverted", folder_name)

            self.__controller = Controller(mealy_machine=kiss_mealy,
                                           world=self.world,
                                           name=self.name,
                                           synth_time=time)
            print(f"NAME:\t{self.__name} ({self.__id})")
            print(self.__controller)
            Store.save_to_file(str(self.__controller), "controller_table",
                               folder_name)

        except ControllerException as e:
            raise GoalSynthesisFail(self, e)
示例#2
0
    def generate_buchi(specification: str, name: str, path: str = None):
        try:

            print(f"Generating Buchi for...\n{specification}")

            if platform.system() != "Linux":
                command = f"docker run pmallozzi/ltltools ltl2tgba -B {specification} -d"
                result = subprocess.check_output(
                    [command],
                    shell=True,
                    encoding='UTF-8',
                    stderr=subprocess.DEVNULL).splitlines()
            else:
                result = subprocess.check_output(
                    ["ltl2tgba", "-B", specification, "-d"],
                    encoding='UTF-8',
                    stderr=subprocess.DEVNULL).splitlines()

            result = [x for x in result if not ('[Büchi]' in x)]
            result = "".join(result)

            Store.save_to_file(specification, f"{name}_specs.txt", path)
            Store.save_to_file(result, f"{name}_dot.txt", path)
            Store.generate_eps_from_dot(result, name, path)

            print(f"Buchi generated")

        except Exception as e:
            raise e
示例#3
0
文件: __init__.py 项目: pierg/crome
    def create_transition_controller(self, start: Types, finish: Types, t_trans: int) -> Controller:

        t_controller_name = f"TRANS_{start.name}->{finish.name}"

        if self.session_name is None:
            folder_name = f"{self.t_controllers_folder_name}/{t_controller_name}"
        else:
            folder_name = f"{self.session_name}/{self.t_controllers_folder_name}/{t_controller_name}"

        typeset = Typeset({start, finish})
        realizable = False
        for n_steps in range(1, t_trans):
            trans_spec_str = Logic.and_([start.name, Logic.xn_(finish.name, n_steps)])
            trans_spec = Atom(formula=(trans_spec_str, typeset))
            trans_contract = Contract(guarantees=trans_spec)
            try:
                controller_info = trans_contract.get_controller_info(world_ts=self.world.typeset)
                a, g, i, o = controller_info.get_strix_inputs()
                controller_synthesis_input = StringMng.get_controller_synthesis_str(controller_info)
                Store.save_to_file(controller_synthesis_input,
                                   f"t_controller_{start.name}_{finish.name}_specs.txt", folder_name)
                realized, kiss_mealy, time = Strix.generate_controller(a, g, i, o)
                if realized:
                    realizable = True
                    break
            except ControllerException as e:
                raise TransSynthesisFail(self, e)
        if not realizable:
            raise Exception(
                f"Controller [{start.name}, {finish.name}] cannot be synthetized in {t_trans} steps")
        else:
            Store.save_to_file(kiss_mealy, f"{start.name}_{finish.name}_mealy",
                               folder_name)
            # Store.generate_eps_from_dot(dot_mealy, f"{start.name}_{finish.name}_dot",
            #                             folder_name)

            t_controller = Controller(mealy_machine=kiss_mealy, world=self.world, name=t_controller_name,
                                      synth_time=time)
            Store.save_to_file(str(t_controller), f"{start.name}_{finish.name}_table", folder_name)

            return t_controller
示例#4
0
from tools.persistence import Persistence
from running_example import output_folder_name
from tools.storage import Store
"""Load CGG"""
cgg = Persistence.load_cgg(output_folder_name)
"""Launch a simulation of n_steps where each contexts does change for at least t_min_context """
run = cgg.orchestrate(n_steps=50, t_min_context=6)
print(run)
"""Save simulation as text file"""
Store.save_to_file(str(run),
                   file_name="simulation.txt",
                   output_folder_name=output_folder_name)
示例#5
0
文件: run_crome.py 项目: pierg/crome
    t_t_controllers = 0
    n_t_controllers = 0
    for key, controller in cgg.t_controllers.items():
        t_t_controllers += controller.synth_time
        n_t_controllers += 1

    res = ""
    res += f"TIME CGG BUILD  \t= {t_cgg}\n"
    res += f"NUMBER OF S-CTRL\t= {n_s_controllers}\n"
    res += f"NUMBER OF STATES\t= {', '.join(states)}\n"
    res += f"NUMBER OF TRANSITIONS\t= {', '.join(transitions)}\n"
    res += f"\nNUMBER OF T-CTRL\t= {n_t_controllers}\n"
    res += f"TIME S-CTRL     \t= {t_s_controllers}\n"
    res += f"TIME T-CTRL     \t= {t_t_controllers}\n"
    res += f"TIME TOTAL      \t= {t_cgg + t_s_controllers + t_t_controllers}\n\n"

    print(f"\n\nRESULTS:\n{res}")

    """Launch a simulation of n_steps where each contexts does change for at least t_min_context """
    run = cgg.orchestrate(n_steps=50, t_min_context=6)
    print(run)

    Store.save_to_file(f"{res}", f"results.txt", absolute_folder_path=f"{result_folder}")

    """Save simulation as text file"""
    Store.save_to_file(str(run), file_name="run.txt", absolute_folder_path=f"{result_folder}")


except CGGException as e:
    raise e
示例#6
0
文件: __init__.py 项目: pierg/crome
 def save(self):
     Store.save_to_file(str(self), "cgg.txt", self.session_name)
示例#7
0
from tools.strings import StringMng
from tools.strix import Strix

path = os.path.abspath(os.path.dirname(__file__))

if len(sys.argv) > 1:
    controller_name = sys.argv[1]
else:
    controller_name = "5"

print(f"controller selected: {path}/controller_specs/{controller_name}.txt")

a, g, i, o = StringMng.parse_controller_specification_from_file(
    f"{path}/controller_specs/{controller_name}.txt")
realizable, kiss_format, exec_time = Strix.generate_controller(a, g, i, o)
controller = Controller(mealy_machine=kiss_format)

Persistence.dump_controller(controller, f"{path}/controller_specs",
                            controller_name)

print("\n~~~MEALY MACHINE~~~\n" + str(controller))
Store.save_to_file(str(controller),
                   f"{controller_name}_table.txt",
                   absolute_folder_path=f"{path}/controller_specs")

run = controller.simulate()
print("\n\n\n~~~SIMULATION OF A RUN~~~\n" + run)
Store.save_to_file(str(run),
                   f"{controller_name}_run.txt",
                   absolute_folder_path=f"{path}/controller_specs")