From 61c5746c664de114ef569d45056c9194d316a8fe Mon Sep 17 00:00:00 2001 From: Luca Framba Date: Fri, 3 Nov 2023 15:29:21 +0100 Subject: [PATCH 01/17] Added engine_subprocess time to metrics of the result given by pddl/anytimepddl engines and used this time in the report to print the overhead % --- unified_planning/engines/pddl_planner.py | 9 ++++- up_test_cases/report.py | 50 ++++++++++++++++++++---- 2 files changed, 50 insertions(+), 9 deletions(-) diff --git a/unified_planning/engines/pddl_planner.py b/unified_planning/engines/pddl_planner.py index 2a7c908a6..24a869b13 100644 --- a/unified_planning/engines/pddl_planner.py +++ b/unified_planning/engines/pddl_planner.py @@ -187,6 +187,7 @@ def _solve( cmd = self._get_anytime_cmd( domain_filename, problem_filename, plan_filename ) + process_start = time.time() if output_stream is None: # If we do not have an output stream to write to, we simply call # a subprocess and retrieve the final output and error with communicate @@ -229,6 +230,7 @@ def _solve( ) timeout_occurred, (proc_out, proc_err), retval = exec_res + process_end = time.time() logs.append(up.engines.results.LogMessage(LogLevel.INFO, "".join(proc_out))) logs.append( up.engines.results.LogMessage(LogLevel.ERROR, "".join(proc_err)) @@ -237,18 +239,21 @@ def _solve( plan = self._plan_from_file( problem, plan_filename, self._writer.get_item_named ) + metrics = {} + metrics["pddl_planner_subprocess_time"] = str(process_end - process_start) if timeout_occurred and retval != 0: return PlanGenerationResult( PlanGenerationResultStatus.TIMEOUT, plan=plan, - log_messages=logs, engine_name=self.name, + metrics=metrics, + log_messages=logs, ) status: PlanGenerationResultStatus = self._result_status( problem, plan, retval, logs ) res = PlanGenerationResult( - status, plan, log_messages=logs, engine_name=self.name + status, plan, engine_name=self.name, metrics=metrics, log_messages=logs ) problem_kind = problem.kind if problem_kind.has_continuous_time() or problem_kind.has_discrete_time(): diff --git a/up_test_cases/report.py b/up_test_cases/report.py index f4de05d3e..9b1ae8e4b 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -259,8 +259,26 @@ def report_oneshot( ) if not outcome.ok(): errors.append((planner_id, name)) - runtime = "{:.3f}s".format(end - start).ljust(10) - print(status, " ", runtime, outcome) + total_execution_time = end - start + subprocess_time_str = None + if result.metrics is not None: + subprocess_time_str = result.metrics.get( + "pddl_planner_subprocess_time", None + ) + if subprocess_time_str is not None: + subprocess_time = float(subprocess_time_str) + # overhead_percentage = 1-subprocess_time/total_execution_time + overhead_percentage = ( + total_execution_time - subprocess_time + ) / subprocess_time + runtime_report = "{:.3f}s({:.3%})".format( + total_execution_time, overhead_percentage + ).ljust(15) + else: + runtime_report = "{:.3f}s".format(total_execution_time).ljust( + 15 + ) + print(status, " ", runtime_report, outcome) except Exception as e: print(f"{bcolors.ERR}CRASH{bcolors.ENDC}", e) @@ -375,8 +393,26 @@ def report_anytime( outcome += check_all_optimal_solutions( test_case, metrics_evaluations ) - runtime = "{:.3f}s".format(end - start).ljust(10) - print(status, " ", runtime, outcome) + total_execution_time = end - start + subprocess_time_str = None + if result.metrics is not None: + subprocess_time_str = result.metrics.get( + "pddl_planner_subprocess_time", None + ) + if subprocess_time_str is not None: + subprocess_time = float(subprocess_time_str) + # overhead_percentage = 1-subprocess_time/total_execution_time + overhead_percentage = ( + total_execution_time - subprocess_time + ) / subprocess_time + runtime_report = "{:.3f}s({:.3%})".format( + total_execution_time, overhead_percentage + ).ljust(15) + else: + runtime_report = "{:.3f}s".format(total_execution_time).ljust( + 15 + ) + print(status, " ", runtime_report, outcome) except Exception as e: print(f"{bcolors.ERR}CRASH{bcolors.ENDC}", e) @@ -428,7 +464,7 @@ def applicable_validators(pb, plan): result = validator.validate(test_case.problem, valid_plan) end = time.time() print(str(result.status.name).ljust(25), end=" ") - runtime = "{:.3f}s".format(end - start).ljust(10) + runtime = "{:.3f}s".format(end - start).ljust(15) print(runtime, end="") if result.status == ValidationResultStatus.VALID: print(Ok("Valid")) @@ -451,7 +487,7 @@ def applicable_validators(pb, plan): result = validator.validate(test_case.problem, invalid_plan) end = time.time() print(str(result.status.name).ljust(25), end=" ") - runtime = "{:.3f}s".format(end - start).ljust(10) + runtime = "{:.3f}s".format(end - start).ljust(15) print(runtime, end="") if result.status == ValidationResultStatus.INVALID: print(Ok("Invalid")) @@ -518,7 +554,7 @@ def is_grounder(engine_name): outcome = check_grounding_result(test_case, result) if not outcome.ok(): errors.append((engine_id, name)) - runtime = "{:.3f}s".format(end - start).ljust(10) + runtime = "{:.3f}s".format(end - start).ljust(15) print(status, " ", runtime, outcome) except Exception as e: From dd7f3ab410d10b7162aa1d022e6e5845c6cd90fa Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Tue, 7 Nov 2023 15:57:24 +0100 Subject: [PATCH 02/17] Added extra_engine_info in the result --- setup.py | 8 ++-- .../engines/oversubscription_planner.py | 1 + .../engines/pddl_anytime_planner.py | 1 + unified_planning/engines/pddl_planner.py | 12 ++++-- unified_planning/engines/results.py | 6 +++ up_test_cases/report.py | 38 +++++++++---------- 6 files changed, 39 insertions(+), 27 deletions(-) diff --git a/setup.py b/setup.py index 8317b0a9f..6a12574ed 100644 --- a/setup.py +++ b/setup.py @@ -27,9 +27,9 @@ "tamer": ["up-tamer==1.0.0.4.dev1"], "enhsp": ["up-enhsp==0.0.21"], "fast-downward": ["up-fast-downward==0.4.0"], - "lpg": ["up-lpg==0.0.7"], + "lpg": ["up-lpg==0.0.8"], "fmap": ["up-fmap==0.0.10"], - "aries": ["up-aries>=0.2.0"], + "aries": ["up-aries>=0.2.1"], "symk": ["up-symk>=1.0.1"], "engines": [ "tarski[arithmetic]", @@ -37,9 +37,9 @@ "up-tamer==1.0.0.4.dev1", "up-enhsp==0.0.21", "up-fast-downward==0.4.0", - "up-lpg==0.0.7", + "up-lpg==0.0.8", "up-fmap==0.0.10", - "up-aries>=0.2.0", + "up-aries>=0.2.1", "up-symk>=1.0.1", ], "plot": [ diff --git a/unified_planning/engines/oversubscription_planner.py b/unified_planning/engines/oversubscription_planner.py index f66251f75..81db59fac 100644 --- a/unified_planning/engines/oversubscription_planner.py +++ b/unified_planning/engines/oversubscription_planner.py @@ -173,6 +173,7 @@ def _solve( self.name, metrics=res.metrics, log_messages=res.log_messages, + extra_engine_info=res.extra_engine_info, ) elif res.status == PlanGenerationResultStatus.TIMEOUT: return PlanGenerationResult( diff --git a/unified_planning/engines/pddl_anytime_planner.py b/unified_planning/engines/pddl_anytime_planner.py index 96ccbe64c..635b2d257 100644 --- a/unified_planning/engines/pddl_anytime_planner.py +++ b/unified_planning/engines/pddl_anytime_planner.py @@ -208,6 +208,7 @@ def _generate_last_result( solve_result.engine_name, solve_result.metrics, solve_result.log_messages, + solve_result.extra_engine_info, ) return res diff --git a/unified_planning/engines/pddl_planner.py b/unified_planning/engines/pddl_planner.py index 24a869b13..d9f3974dc 100644 --- a/unified_planning/engines/pddl_planner.py +++ b/unified_planning/engines/pddl_planner.py @@ -239,21 +239,25 @@ def _solve( plan = self._plan_from_file( problem, plan_filename, self._writer.get_item_named ) - metrics = {} - metrics["pddl_planner_subprocess_time"] = str(process_end - process_start) + extra_engine_info = {} + extra_engine_info["internal_time"] = str(process_end - process_start) if timeout_occurred and retval != 0: return PlanGenerationResult( PlanGenerationResultStatus.TIMEOUT, plan=plan, engine_name=self.name, - metrics=metrics, log_messages=logs, + extra_engine_info=extra_engine_info, ) status: PlanGenerationResultStatus = self._result_status( problem, plan, retval, logs ) res = PlanGenerationResult( - status, plan, engine_name=self.name, metrics=metrics, log_messages=logs + status, + plan, + engine_name=self.name, + log_messages=logs, + extra_engine_info=extra_engine_info, ) problem_kind = problem.kind if problem_kind.has_continuous_time() or problem_kind.has_discrete_time(): diff --git a/unified_planning/engines/results.py b/unified_planning/engines/results.py index 487c8216e..ad40b32c8 100644 --- a/unified_planning/engines/results.py +++ b/unified_planning/engines/results.py @@ -145,6 +145,7 @@ class PlanGenerationResult(Result): engine_name: str metrics: Optional[Dict[str, str]] = field(default=None) log_messages: Optional[List[LogMessage]] = field(default=None) + extra_engine_info: Optional[Dict[str, str]] = field(default=None) def __post__init(self): # Checks that plan and status are consistent @@ -235,6 +236,7 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, + result.extra_engine_info, ) elif problem.epsilon is None or ( engine_epsilon is not None and problem.epsilon < engine_epsilon @@ -250,6 +252,7 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, + result.extra_engine_info, ) elif result.status == PlanGenerationResultStatus.SOLVED_OPTIMALLY: return PlanGenerationResult( @@ -258,6 +261,7 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, + result.extra_engine_info, ) return result @@ -274,6 +278,7 @@ class ValidationResult(Result): ) reason: Optional[FailedValidationReason] = field(default=None) inapplicable_action: Optional[up.plans.ActionInstance] = field(default=None) + extra_engine_info: Optional[Dict[str, str]] = field(default=None) def __post_init__(self): assert ( @@ -313,6 +318,7 @@ class CompilerResult(Result): ] engine_name: str log_messages: Optional[List[LogMessage]] = field(default=None) + extra_engine_info: Optional[Dict[str, str]] = field(default=None) def _post_init(self): # Check that compiled problem and map_back_action_instance are consistent with each other diff --git a/up_test_cases/report.py b/up_test_cases/report.py index 9b1ae8e4b..e2d62ff53 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -260,17 +260,17 @@ def report_oneshot( if not outcome.ok(): errors.append((planner_id, name)) total_execution_time = end - start - subprocess_time_str = None - if result.metrics is not None: - subprocess_time_str = result.metrics.get( - "pddl_planner_subprocess_time", None + internal_time_str = None + if result.extra_engine_info is not None: + internal_time_str = result.extra_engine_info.get( + "internal_time", None ) - if subprocess_time_str is not None: - subprocess_time = float(subprocess_time_str) - # overhead_percentage = 1-subprocess_time/total_execution_time + if internal_time_str is not None: + internal_time = float(internal_time_str) + # overhead_percentage = 1-internal_time/total_execution_time overhead_percentage = ( - total_execution_time - subprocess_time - ) / subprocess_time + total_execution_time - internal_time + ) / internal_time runtime_report = "{:.3f}s({:.3%})".format( total_execution_time, overhead_percentage ).ljust(15) @@ -394,18 +394,18 @@ def report_anytime( test_case, metrics_evaluations ) total_execution_time = end - start - subprocess_time_str = None - if result.metrics is not None: - subprocess_time_str = result.metrics.get( - "pddl_planner_subprocess_time", None + internal_time_str = None + if result.extra_engine_info is not None: + internal_time_str = result.extra_engine_info.get( + "internal_time", None ) - if subprocess_time_str is not None: - subprocess_time = float(subprocess_time_str) - # overhead_percentage = 1-subprocess_time/total_execution_time + if internal_time_str is not None: + internal_time = float(internal_time_str) + # overhead_percentage = 1-internal_time/total_execution_time overhead_percentage = ( - total_execution_time - subprocess_time - ) / subprocess_time - runtime_report = "{:.3f}s({:.3%})".format( + total_execution_time - internal_time + ) / internal_time + runtime_report = "{:.3f}s({:.0%})".format( total_execution_time, overhead_percentage ).ljust(15) else: From e6017c2160bd652c981a3ccadb09178487c73db7 Mon Sep 17 00:00:00 2001 From: Luca Framba Date: Wed, 8 Nov 2023 14:03:07 +0100 Subject: [PATCH 03/17] add(tests): Added package performance --- up_test_cases/performance/__init__.py | 4 + up_test_cases/performance/numeric/__init__.py | 4 + .../performance/numeric/depots/__init__.py | 9 ++ .../depots/pddl_files/depots_domain.pddl | 54 ++++++++ .../depots/pddl_files/depots_pfile10.pddl | 70 ++++++++++ .../depots/pddl_files/depots_pfile11.pddl | 88 ++++++++++++ .../performance/numeric/farmlands/__init__.py | 9 ++ .../pddl_files/farmland_10_1000_1229.pddl | 67 +++++++++ .../pddl_files/farmland_10_400_1229.pddl | 67 +++++++++ .../farmlands/pddl_files/farmland_domain.pddl | 23 +++ .../numeric/fn_counters/__init__.py | 9 ++ .../fn_counters/pddl_files/fn_counters_8.pddl | 31 +++++ .../pddl_files/fn_counters_domain.pddl | 29 ++++ .../numeric/plant_watering/__init__.py | 9 ++ .../pddl_files/plant_watering_4_3.pddl | 49 +++++++ .../pddl_files/plant_watering_domain.pddl | 105 ++++++++++++++ .../performance/numeric/rovers/__init__.py | 9 ++ .../rovers/pddl_files/rovers_domain.pddl | 131 ++++++++++++++++++ .../rovers/pddl_files/rovers_pfile5.pddl | 94 +++++++++++++ .../performance/numeric/sailing/__init__.py | 9 ++ .../sailing/pddl_files/sailing_4_10_1229.pddl | 54 ++++++++ .../sailing/pddl_files/sailing_domain.pddl | 58 ++++++++ .../performance/temporal/__init__.py | 4 + .../performance/temporal/depot/__init__.py | 9 ++ .../depot/pddl_files/depots_domain.pddl | 52 +++++++ .../depot/pddl_files/depots_pfile10.pddl | 109 +++++++++++++++ .../depot/pddl_files/depots_pfile11.pddl | 127 +++++++++++++++++ 27 files changed, 1283 insertions(+) create mode 100644 up_test_cases/performance/__init__.py create mode 100644 up_test_cases/performance/numeric/__init__.py create mode 100644 up_test_cases/performance/numeric/depots/__init__.py create mode 100644 up_test_cases/performance/numeric/depots/pddl_files/depots_domain.pddl create mode 100644 up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10.pddl create mode 100644 up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11.pddl create mode 100644 up_test_cases/performance/numeric/farmlands/__init__.py create mode 100755 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl create mode 100755 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl create mode 100755 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl create mode 100644 up_test_cases/performance/numeric/fn_counters/__init__.py create mode 100755 up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl create mode 100755 up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl create mode 100644 up_test_cases/performance/numeric/plant_watering/__init__.py create mode 100755 up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl create mode 100755 up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl create mode 100644 up_test_cases/performance/numeric/rovers/__init__.py create mode 100644 up_test_cases/performance/numeric/rovers/pddl_files/rovers_domain.pddl create mode 100644 up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5.pddl create mode 100644 up_test_cases/performance/numeric/sailing/__init__.py create mode 100755 up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl create mode 100755 up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl create mode 100644 up_test_cases/performance/temporal/__init__.py create mode 100644 up_test_cases/performance/temporal/depot/__init__.py create mode 100644 up_test_cases/performance/temporal/depot/pddl_files/depots_domain.pddl create mode 100644 up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl create mode 100644 up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl diff --git a/up_test_cases/performance/__init__.py b/up_test_cases/performance/__init__.py new file mode 100644 index 000000000..79f55a6ae --- /dev/null +++ b/up_test_cases/performance/__init__.py @@ -0,0 +1,4 @@ +from functools import partial +from utils import _get_test_cases # type: ignore + +get_test_cases = partial(_get_test_cases, "performance") diff --git a/up_test_cases/performance/numeric/__init__.py b/up_test_cases/performance/numeric/__init__.py new file mode 100644 index 000000000..7bc7cfd1e --- /dev/null +++ b/up_test_cases/performance/numeric/__init__.py @@ -0,0 +1,4 @@ +from functools import partial +from utils import _get_test_cases # type: ignore + +get_test_cases = partial(_get_test_cases, "performance.numeric") diff --git a/up_test_cases/performance/numeric/depots/__init__.py b/up_test_cases/performance/numeric/depots/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/depots/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/depots/pddl_files/depots_domain.pddl b/up_test_cases/performance/numeric/depots/pddl_files/depots_domain.pddl new file mode 100644 index 000000000..12249891f --- /dev/null +++ b/up_test_cases/performance/numeric/depots/pddl_files/depots_domain.pddl @@ -0,0 +1,54 @@ +(define (domain Depot) +;(:requirements :typing :fluents) +(:types place locatable - object + depot distributor - place + truck hoist surface - locatable + pallet crate - surface) + +(:predicates (at ?x - locatable ?y - place) + (on ?x - crate ?y - surface) + (in ?x - crate ?y - truck) + (lifting ?x - hoist ?y - crate) + (available ?x - hoist) + (clear ?x - surface) +) + +(:functions + (load_limit ?t - truck) + (current_load ?t - truck) + (weight ?c - crate) + (fuel-cost) +) + +(:action Drive +:parameters (?x - truck ?y - place ?z - place) +:precondition (and (at ?x ?y)) +:effect (and (not (at ?x ?y)) (at ?x ?z) + (increase (fuel-cost) 10))) + +(:action Lift +:parameters (?x - hoist ?y - crate ?z - surface ?p - place) +:precondition (and (at ?x ?p) (available ?x) (at ?y ?p) (on ?y ?z) (clear ?y)) +:effect (and (not (at ?y ?p)) (lifting ?x ?y) (not (clear ?y)) (not (available ?x)) + (clear ?z) (not (on ?y ?z)) (increase (fuel-cost) 1))) + +(:action Drop +:parameters (?x - hoist ?y - crate ?z - surface ?p - place) +:precondition (and (at ?x ?p) (at ?z ?p) (clear ?z) (lifting ?x ?y)) +:effect (and (available ?x) (not (lifting ?x ?y)) (at ?y ?p) (not (clear ?z)) (clear ?y) + (on ?y ?z))) + +(:action Load +:parameters (?x - hoist ?y - crate ?z - truck ?p - place) +:precondition (and (at ?x ?p) (at ?z ?p) (lifting ?x ?y) + (<= (+ (current_load ?z) (weight ?y)) (load_limit ?z))) +:effect (and (not (lifting ?x ?y)) (in ?y ?z) (available ?x) + (increase (current_load ?z) (weight ?y)))) + +(:action Unload +:parameters (?x - hoist ?y - crate ?z - truck ?p - place) +:precondition (and (at ?x ?p) (at ?z ?p) (available ?x) (in ?y ?z)) +:effect (and (not (in ?y ?z)) (not (available ?x)) (lifting ?x ?y) + (decrease (current_load ?z) (weight ?y)))) + +) diff --git a/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10.pddl b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10.pddl new file mode 100644 index 000000000..33399ce1a --- /dev/null +++ b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10.pddl @@ -0,0 +1,70 @@ +(define (problem depotprob7654) (:domain Depot) +(:objects + depot0 depot1 depot2 - depot + distributor0 distributor1 distributor2 - distributor + truck0 truck1 - truck + pallet0 pallet1 pallet2 pallet3 pallet4 pallet5 - pallet + crate0 crate1 crate2 crate3 crate4 crate5 - crate + hoist0 hoist1 hoist2 hoist3 hoist4 hoist5 - hoist) +(:init + (at pallet0 depot0) + (clear crate1) + (at pallet1 depot1) + (clear crate0) + (at pallet2 depot2) + (clear crate4) + (at pallet3 distributor0) + (clear crate5) + (at pallet4 distributor1) + (clear pallet4) + (at pallet5 distributor2) + (clear crate3) + (at truck0 depot1) + (= (current_load truck0) 0) + (= (load_limit truck0) 370) + (at truck1 depot2) + (= (current_load truck1) 0) + (= (load_limit truck1) 287) + (at hoist0 depot0) + (available hoist0) + (at hoist1 depot1) + (available hoist1) + (at hoist2 depot2) + (available hoist2) + (at hoist3 distributor0) + (available hoist3) + (at hoist4 distributor1) + (available hoist4) + (at hoist5 distributor2) + (available hoist5) + (at crate0 depot1) + (on crate0 pallet1) + (= (weight crate0) 96) + (at crate1 depot0) + (on crate1 pallet0) + (= (weight crate1) 72) + (at crate2 distributor2) + (on crate2 pallet5) + (= (weight crate2) 74) + (at crate3 distributor2) + (on crate3 crate2) + (= (weight crate3) 16) + (at crate4 depot2) + (on crate4 pallet2) + (= (weight crate4) 23) + (at crate5 distributor0) + (on crate5 pallet3) + (= (weight crate5) 42) + (= (fuel-cost) 0) +) + +(:goal (and + (on crate0 crate4) + (on crate2 pallet3) + (on crate3 pallet0) + (on crate4 pallet5) + ) +) + +;(:metric minimize (total-time)) +) diff --git a/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11.pddl b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11.pddl new file mode 100644 index 000000000..f46aa30bb --- /dev/null +++ b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11.pddl @@ -0,0 +1,88 @@ +(define (problem depotprob8765) (:domain Depot) +(:objects + depot0 depot1 depot2 - depot + distributor0 distributor1 distributor2 - distributor + truck0 truck1 - truck + pallet0 pallet1 pallet2 pallet3 pallet4 pallet5 - pallet + crate0 crate1 crate2 crate3 crate4 crate5 crate6 crate7 crate8 crate9 - crate + hoist0 hoist1 hoist2 hoist3 hoist4 hoist5 - hoist) +(:init + (at pallet0 depot0) + (clear crate1) + (at pallet1 depot1) + (clear crate3) + (at pallet2 depot2) + (clear crate9) + (at pallet3 distributor0) + (clear pallet3) + (at pallet4 distributor1) + (clear pallet4) + (at pallet5 distributor2) + (clear crate8) + (at truck0 depot2) + (= (current_load truck0) 0) + (= (load_limit truck0) 336) + (at truck1 distributor0) + (= (current_load truck1) 0) + (= (load_limit truck1) 366) + (at hoist0 depot0) + (available hoist0) + (at hoist1 depot1) + (available hoist1) + (at hoist2 depot2) + (available hoist2) + (at hoist3 distributor0) + (available hoist3) + (at hoist4 distributor1) + (available hoist4) + (at hoist5 distributor2) + (available hoist5) + (at crate0 depot1) + (on crate0 pallet1) + (= (weight crate0) 42) + (at crate1 depot0) + (on crate1 pallet0) + (= (weight crate1) 6) + (at crate2 depot2) + (on crate2 pallet2) + (= (weight crate2) 74) + (at crate3 depot1) + (on crate3 crate0) + (= (weight crate3) 64) + (at crate4 depot2) + (on crate4 crate2) + (= (weight crate4) 61) + (at crate5 depot2) + (on crate5 crate4) + (= (weight crate5) 79) + (at crate6 distributor2) + (on crate6 pallet5) + (= (weight crate6) 29) + (at crate7 distributor2) + (on crate7 crate6) + (= (weight crate7) 77) + (at crate8 distributor2) + (on crate8 crate7) + (= (weight crate8) 19) + (at crate9 depot2) + (on crate9 crate5) + (= (weight crate9) 98) + (= (fuel-cost) 0) +) + +(:goal (and + (on crate0 crate7) + (on crate1 pallet4) + (on crate2 pallet5) + (on crate3 crate9) + (on crate4 pallet0) + (on crate5 pallet2) + (on crate6 crate5) + (on crate7 crate1) + (on crate8 pallet3) + (on crate9 crate2) + ) +) + +;(:metric minimize (fuel-cost)) +) diff --git a/up_test_cases/performance/numeric/farmlands/__init__.py b/up_test_cases/performance/numeric/farmlands/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/farmlands/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl new file mode 100755 index 000000000..2d1ad3323 --- /dev/null +++ b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl @@ -0,0 +1,67 @@ +;;Setting seed to 1229 +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (problem instance_10_1000_1229_ladder) + (:domain farmland) + (:objects + farm0 farm1 farm2 farm3 farm4 farm5 farm6 farm7 farm8 farm9 - farm + ) + (:init + (= (x farm0) 1) + (= (x farm1) 1000) + (= (x farm2) 0) + (= (x farm3) 0) + (= (x farm4) 0) + (= (x farm5) 1) + (= (x farm6) 1) + (= (x farm7) 0) + (= (x farm8) 0) + (= (x farm9) 0) + + (adj farm0 farm1) + (adj farm0 farm5) + (adj farm1 farm0) + (adj farm1 farm2) + (adj farm1 farm6) + (adj farm2 farm1) + (adj farm2 farm3) + (adj farm2 farm7) + (adj farm3 farm8) + (adj farm3 farm2) + (adj farm3 farm4) + (adj farm4 farm9) + (adj farm4 farm3) + (adj farm5 farm0) + (adj farm5 farm6) + (adj farm6 farm1) + (adj farm6 farm5) + (adj farm6 farm7) + (adj farm7 farm8) + (adj farm7 farm2) + (adj farm7 farm6) + (adj farm8 farm9) + (adj farm8 farm3) + (adj farm8 farm7) + (adj farm9 farm8) + (adj farm9 farm4) + + (= (cost) 0) + ) + (:goal + (and + (>= (x farm0) 1) + (>= (x farm1) 1) + (>= (x farm2) 1) + (>= (x farm3) 1) + (>= (x farm4) 1) + (>= (x farm5) 1) + (>= (x farm6) 1) + (>= (x farm7) 1) + (>= (x farm8) 1) + (>= (x farm9) 1) + + (>= (+ (* 1.7 (x farm0))(+ (* 1.0 (x farm1))(+ (* 1.3 (x farm2))(+ (* 1.1 (x farm3))(+ (* 1.4 (x farm4))(+ (* 1.9 (x farm5))(+ (* 1.3 (x farm6))(+ (* 1.4 (x farm7))(+ (* 1.4 (x farm8))(+ (* 1.1 (x farm9)) 0)))))))))) 1400.0) + ) + ) +) + + diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl new file mode 100755 index 000000000..34486eaec --- /dev/null +++ b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl @@ -0,0 +1,67 @@ +;;Setting seed to 1229 +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (problem instance_10_400_1229_ladder) + (:domain farmland) + (:objects + farm0 farm1 farm2 farm3 farm4 farm5 farm6 farm7 farm8 farm9 - farm + ) + (:init + (= (x farm0) 1) + (= (x farm1) 400) + (= (x farm2) 0) + (= (x farm3) 0) + (= (x farm4) 0) + (= (x farm5) 1) + (= (x farm6) 1) + (= (x farm7) 0) + (= (x farm8) 0) + (= (x farm9) 0) + + (adj farm0 farm1) + (adj farm0 farm5) + (adj farm1 farm0) + (adj farm1 farm2) + (adj farm1 farm6) + (adj farm2 farm1) + (adj farm2 farm3) + (adj farm2 farm7) + (adj farm3 farm8) + (adj farm3 farm2) + (adj farm3 farm4) + (adj farm4 farm9) + (adj farm4 farm3) + (adj farm5 farm0) + (adj farm5 farm6) + (adj farm6 farm1) + (adj farm6 farm5) + (adj farm6 farm7) + (adj farm7 farm8) + (adj farm7 farm2) + (adj farm7 farm6) + (adj farm8 farm9) + (adj farm8 farm3) + (adj farm8 farm7) + (adj farm9 farm8) + (adj farm9 farm4) + + (= (cost) 0) + ) + (:goal + (and + (>= (x farm0) 1) + (>= (x farm1) 1) + (>= (x farm2) 1) + (>= (x farm3) 1) + (>= (x farm4) 1) + (>= (x farm5) 1) + (>= (x farm6) 1) + (>= (x farm7) 1) + (>= (x farm8) 1) + (>= (x farm9) 1) + + (>= (+ (* 1.7 (x farm0))(+ (* 1.0 (x farm1))(+ (* 1.3 (x farm2))(+ (* 1.1 (x farm3))(+ (* 1.4 (x farm4))(+ (* 1.9 (x farm5))(+ (* 1.3 (x farm6))(+ (* 1.4 (x farm7))(+ (* 1.4 (x farm8))(+ (* 1.1 (x farm9)) 0)))))))))) 560.0) + ) + ) +) + + diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl new file mode 100755 index 000000000..fda581cbc --- /dev/null +++ b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl @@ -0,0 +1,23 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (domain farmland) + (:types farm -object) + (:predicates (adj ?f1 ?f2 -farm)) + (:functions + (x ?b -farm) + (cost) + ) + + ;; Move a person from a unit f1 to a unit f2 + (:action move-fast + :parameters (?f1 ?f2 -farm) + :precondition (and (not (= ?f1 ?f2)) (>= (x ?f1) 4) (adj ?f1 ?f2) ) + :effect (and(decrease (x ?f1) 4) (increase (x ?f2) 2) (increase (cost) 1)) + ) + + (:action move-slow + :parameters (?f1 ?f2 -farm) + :precondition (and (not (= ?f1 ?f2)) (>= (x ?f1) 1) (adj ?f1 ?f2)) + :effect (and(decrease (x ?f1) 1) (increase (x ?f2) 1)) + ) + +) diff --git a/up_test_cases/performance/numeric/fn_counters/__init__.py b/up_test_cases/performance/numeric/fn_counters/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/fn_counters/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl new file mode 100755 index 000000000..c5c1dfd50 --- /dev/null +++ b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl @@ -0,0 +1,31 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (problem instance_8) + (:domain fn-counters) + (:objects + c0 c1 c2 c3 c4 c5 c6 c7 - counter + ) + + (:init + (= (max_int) 16) + (= (value c0) 0) + (= (value c1) 0) + (= (value c2) 0) + (= (value c3) 0) + (= (value c4) 0) + (= (value c5) 0) + (= (value c6) 0) + (= (value c7) 0) + ) + + (:goal (and + (<= (+ (value c0) 1) (value c1)) + (<= (+ (value c1) 1) (value c2)) + (<= (+ (value c2) 1) (value c3)) + (<= (+ (value c3) 1) (value c4)) + (<= (+ (value c4) 1) (value c5)) + (<= (+ (value c5) 1) (value c6)) + (<= (+ (value c6) 1) (value c7)) + )) + + +) diff --git a/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl new file mode 100755 index 000000000..01b8ea1a9 --- /dev/null +++ b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl @@ -0,0 +1,29 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; counters-ineq-rnd domain, functional strips version +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Same domain than counters-ineq, only the instances will differ, since the initial values are set randomly. + +(define (domain fn-counters) + ;(:requirements :strips :typing :equality :adl) + (:types counter) + + (:functions + (value ?c - counter);; - int ;; The value shown in counter ?c + (max_int);; - int ;; The maximum integer we consider - a static value + ) + + ;; Increment the value in the given counter by one + (:action increment + :parameters (?c - counter) + :precondition (and (<= (+ (value ?c) 1) (max_int))) + :effect (and (increase (value ?c) 1)) + ) + + ;; Decrement the value in the given counter by one + (:action decrement + :parameters (?c - counter) + :precondition (and (>= (value ?c) 1)) + :effect (and (decrease (value ?c) 1)) + ) +) diff --git a/up_test_cases/performance/numeric/plant_watering/__init__.py b/up_test_cases/performance/numeric/plant_watering/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/plant_watering/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl new file mode 100755 index 000000000..4c572f2f7 --- /dev/null +++ b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl @@ -0,0 +1,49 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (problem instance_4_3) + (:domain mt-plant-watering) + (:objects + tap1 - tap + agent1 - agent + plant3 plant1 plant4 plant2 - plant + ) + + (:init + (= (max_int) 80) + (= (maxx) 4) + (= (minx) 1) + (= (maxy) 4) + (= (miny) 1) + (= (carrying) 0) + (= (total_poured) 0) + (= (total_loaded) 0) + (= (poured plant1) 0) + (= (poured plant2) 0) + (= (poured plant3) 0) + (= (poured plant4) 0) + (= (x agent1) 1) + (= (y agent1) 4) + (= (x plant2) 4) + (= (y plant2) 4) + (= (x plant3) 4) + (= (y plant3) 4) + (= (x tap1) 1) + (= (y tap1) 1) + (= (x plant4) 3) + (= (y plant4) 3) + (= (x plant1) 3) + (= (y plant1) 3) + ) + + (:goal (and + (= (poured plant1) 10) + (= (poured plant2) 5) + (= (poured plant3) 7) + (= (poured plant4) 4) + (= (total_poured) (+ (+ (+ (poured plant1) (poured plant2)) (poured plant3)) (poured plant4)) ) + )) + + + + + +) diff --git a/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl new file mode 100755 index 000000000..7ac0e010f --- /dev/null +++ b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl @@ -0,0 +1,105 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Plant watering domain - metric-ff version +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; An agent on a grid-like map aims pos watering some plants by +;;; carrying water from a tap to the plants. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Adapted to do away with the grid (Enrico Scala & Miquel Ramirez, August 2015) +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(define (domain mt-plant-watering) + (:types thing - object + agent plant tap - thing) + + + (:functions + (maxx) ;; bounds + (maxy) ;; bounds + (miny) ;; bounds + (minx) ;; bounds + (x ?t - thing) ;; x coordinate of the location for ?t + (y ?t - thing) ;; y coordinate of the location for ?t + (carrying) ;; The amount of water carried by the agent. + (poured ?p - plant) ;; The amount of water poured to the plant so far. + (total_poured) ;; The total amount of water poured so far. + (total_loaded) ;; The total amount of water retrieved from the tap. + (max_int) ;; The maximum integer we consider - a static value + ) + + ;; Move an agent to a neighboring location + (:action move_up + :parameters (?a - agent) + :precondition (and (<= (+ (y ?a) 1) (maxy))) + :effect (and + (increase (y ?a) 1))) + + (:action move_down + :parameters (?a - agent) + :precondition (and (>= (- (y ?a) 1) (miny))) + :effect (and + (decrease (y ?a) 1))) + + (:action move_right + :parameters (?a - agent) + :precondition (and (<= (+ (x ?a) 1) (maxx))) + :effect (and + (increase (x ?a) 1))) + + (:action move_left + :parameters (?a - agent) + :precondition (and (>= (- (x ?a) 1) (minx))) + :effect (and + (decrease (x ?a) 1))) + + (:action move_up_left + :parameters (?a - agent) + :precondition (and (>= (- (x ?a) 1) (minx)) (<= (+ (y ?a) 1) (maxy))) + :effect (and + (increase (y ?a) 1) (decrease (x ?a) 1))) + + (:action move_up_right + :parameters (?a - agent) + :precondition (and (<= (+ (x ?a) 1) (maxx)) (<= (+ (y ?a) 1) (maxy))) + :effect (and + (increase (y ?a) 1) (increase (x ?a) 1))) + + (:action move_down_left + :parameters (?a - agent) + :precondition (and (>= (- (x ?a) 1) (minx)) (>= (- (y ?a) 1) (miny))) + :effect (and + (decrease (x ?a) 1) (decrease (y ?a) 1) ) + ) + +(:action move_down_right + :parameters (?a - agent) + :precondition (and (<= (+ (x ?a) 1) (maxx)) (>= (- (y ?a) 1) (miny))) + :effect (and + (decrease (y ?a) 1) (increase (x ?a) 1))) + + ;; Load one unit of water from a tap into the agent's bucket. + (:action load + :parameters (?a - agent ?t - tap) + :precondition (and (= (x ?a) (x ?t)) (=(y ?a) (y ?t)) + (<= (+ (total_loaded) 1) (max_int)) + (<= (+ (carrying) 1) (max_int)) + ) + :effect (and (increase (carrying) 1) (increase (total_loaded) 1)) + ) + + ;; Pours one unit of water from the agent's bucket into a plant. + (:action pour + :parameters (?a - agent ?p - plant) + :precondition (and (= (x ?a) (x ?p)) (=(y ?a) (y ?p)) + (>= (carrying) 1) + (<= (+ (total_poured) 1) (max_int)) + (<= (+ (poured ?p) 1) (max_int)) + ) + :effect (and + (decrease (carrying) 1) + (increase (poured ?p) 1) + (increase (total_poured) 1) + ) + ) +) diff --git a/up_test_cases/performance/numeric/rovers/__init__.py b/up_test_cases/performance/numeric/rovers/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/rovers/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/rovers/pddl_files/rovers_domain.pddl b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_domain.pddl new file mode 100644 index 000000000..585137ef2 --- /dev/null +++ b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_domain.pddl @@ -0,0 +1,131 @@ +(define (domain Rover) +;(:requirements :typing :fluents) +(:types rover waypoint store camera mode lander objective) + +(:predicates (at ?x - rover ?y - waypoint) + (at_lander ?x - lander ?y - waypoint) + (can_traverse ?r - rover ?x - waypoint ?y - waypoint) + (equipped_for_soil_analysis ?r - rover) + (equipped_for_rock_analysis ?r - rover) + (equipped_for_imaging ?r - rover) + (empty ?s - store) + (have_rock_analysis ?r - rover ?w - waypoint) + (have_soil_analysis ?r - rover ?w - waypoint) + (full ?s - store) + (calibrated ?c - camera ?r - rover) + (supports ?c - camera ?m - mode) + (available ?r - rover) + (visible ?w - waypoint ?p - waypoint) + (have_image ?r - rover ?o - objective ?m - mode) + (communicated_soil_data ?w - waypoint) + (communicated_rock_data ?w - waypoint) + (communicated_image_data ?o - objective ?m - mode) + (at_soil_sample ?w - waypoint) + (at_rock_sample ?w - waypoint) + (visible_from ?o - objective ?w - waypoint) + (store_of ?s - store ?r - rover) + (calibration_target ?i - camera ?o - objective) + (on_board ?i - camera ?r - rover) + (channel_free ?l - lander) + (in_sun ?w - waypoint) + +) + +(:functions (energy ?r - rover) (recharges) ) + +(:action navigate +:parameters (?x - rover ?y - waypoint ?z - waypoint) +:precondition (and (can_traverse ?x ?y ?z) (available ?x) (at ?x ?y) + (visible ?y ?z) (>= (energy ?x) 8) + ) +:effect (and (decrease (energy ?x) 8) (not (at ?x ?y)) (at ?x ?z) + ) +) + +(:action recharge +:parameters (?x - rover ?w - waypoint) +:precondition (and (at ?x ?w) (in_sun ?w) (<= (energy ?x) 80)) +:effect (and (increase (energy ?x) 20) (increase (recharges) 1)) +) + +(:action sample_soil +:parameters (?x - rover ?s - store ?p - waypoint) +:precondition (and (at ?x ?p)(>= (energy ?x) 3) (at_soil_sample ?p) (equipped_for_soil_analysis ?x) (store_of ?s ?x) (empty ?s) + ) +:effect (and (not (empty ?s)) (full ?s) (decrease (energy ?x) 3) (have_soil_analysis ?x ?p) (not (at_soil_sample ?p)) + ) +) + +(:action sample_rock +:parameters (?x - rover ?s - store ?p - waypoint) +:precondition (and (at ?x ?p) (>= (energy ?x) 5)(at_rock_sample ?p) (equipped_for_rock_analysis ?x) (store_of ?s ?x)(empty ?s) + ) +:effect (and (not (empty ?s)) (full ?s) (decrease (energy ?x) 5) (have_rock_analysis ?x ?p) (not (at_rock_sample ?p)) + ) +) + +(:action drop +:parameters (?x - rover ?y - store) +:precondition (and (store_of ?y ?x) (full ?y) + ) +:effect (and (not (full ?y)) (empty ?y) + ) +) + +(:action calibrate + :parameters (?r - rover ?i - camera ?t - objective ?w - waypoint) + :precondition (and (equipped_for_imaging ?r) (>= (energy ?r) 2)(calibration_target ?i ?t) (at ?r ?w) (visible_from ?t ?w)(on_board ?i ?r) + ) + :effect (and (decrease (energy ?r) 2)(calibrated ?i ?r) ) +) + + + + +(:action take_image + :parameters (?r - rover ?p - waypoint ?o - objective ?i - camera ?m - mode) + :precondition (and (calibrated ?i ?r) + (on_board ?i ?r) + (equipped_for_imaging ?r) + (supports ?i ?m) + (visible_from ?o ?p) + (at ?r ?p) + (>= (energy ?r) 1) + ) + :effect (and (have_image ?r ?o ?m)(not (calibrated ?i ?r))(decrease (energy ?r) 1) + ) +) + +(:action communicate_soil_data + :parameters (?r - rover ?l - lander ?p - waypoint ?x - waypoint ?y - waypoint) + :precondition (and (at ?r ?x)(at_lander ?l ?y)(have_soil_analysis ?r ?p) + (visible ?x ?y)(available ?r)(channel_free ?l)(>= (energy ?r) 4) + ) + :effect (and +(channel_free ?l) (communicated_soil_data ?p)(available ?r)(decrease (energy ?r) 4) + ) +) + +(:action communicate_rock_data + :parameters (?r - rover ?l - lander ?p - waypoint ?x - waypoint ?y - waypoint) + :precondition (and (at ?r ?x)(at_lander ?l ?y)(have_rock_analysis ?r ?p)(>= (energy ?r) 4) + (visible ?x ?y)(available ?r)(channel_free ?l) + ) + :effect (and +(channel_free ?l) +(communicated_rock_data ?p)(available ?r)(decrease (energy ?r) 4) + ) +) + + +(:action communicate_image_data + :parameters (?r - rover ?l - lander ?o - objective ?m - mode ?x - waypoint ?y - waypoint) + :precondition (and (at ?r ?x)(at_lander ?l ?y)(have_image ?r ?o ?m)(visible ?x ?y)(available ?r)(channel_free ?l)(>= (energy ?r) 6) + ) + :effect (and +(channel_free ?l) +(communicated_image_data ?o ?m)(available ?r)(decrease (energy ?r) 6) + ) +) + +) diff --git a/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5.pddl b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5.pddl new file mode 100644 index 000000000..948f18fe8 --- /dev/null +++ b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5.pddl @@ -0,0 +1,94 @@ +(define (problem roverprob2435) (:domain Rover) +(:objects + general - lander + colour high_res low_res - mode + rover0 rover1 - rover + rover0store rover1store - store + waypoint0 waypoint1 waypoint2 waypoint3 - waypoint + camera0 camera1 camera2 - camera + objective0 objective1 objective2 - objective + ) +(:init + (visible waypoint0 waypoint2) + (visible waypoint2 waypoint0) + (visible waypoint1 waypoint0) + (visible waypoint0 waypoint1) + (visible waypoint1 waypoint3) + (visible waypoint3 waypoint1) + (visible waypoint2 waypoint1) + (visible waypoint1 waypoint2) + (visible waypoint3 waypoint0) + (visible waypoint0 waypoint3) + (visible waypoint3 waypoint2) + (visible waypoint2 waypoint3) + (= (recharges) 0) + (at_rock_sample waypoint0) + (in_sun waypoint0) + (at_soil_sample waypoint1) + (at_rock_sample waypoint1) + (at_soil_sample waypoint2) + (at_soil_sample waypoint3) + (at_lander general waypoint3) + (channel_free general) + (= (energy rover0) 50) + (at rover0 waypoint0) + (available rover0) + (store_of rover0store rover0) + (empty rover0store) + (equipped_for_rock_analysis rover0) + (equipped_for_imaging rover0) + (can_traverse rover0 waypoint0 waypoint1) + (can_traverse rover0 waypoint1 waypoint0) + (can_traverse rover0 waypoint0 waypoint3) + (can_traverse rover0 waypoint3 waypoint0) + (= (energy rover1) 50) + (at rover1 waypoint0) + (available rover1) + (store_of rover1store rover1) + (empty rover1store) + (equipped_for_soil_analysis rover1) + (equipped_for_imaging rover1) + (can_traverse rover1 waypoint0 waypoint1) + (can_traverse rover1 waypoint1 waypoint0) + (can_traverse rover1 waypoint1 waypoint2) + (can_traverse rover1 waypoint2 waypoint1) + (can_traverse rover1 waypoint1 waypoint3) + (can_traverse rover1 waypoint3 waypoint1) + (on_board camera0 rover1) + (calibration_target camera0 objective1) + (supports camera0 high_res) + (supports camera0 low_res) + (on_board camera1 rover1) + (calibration_target camera1 objective1) + (supports camera1 colour) + (supports camera1 high_res) + (on_board camera2 rover0) + (calibration_target camera2 objective1) + (supports camera2 colour) + (supports camera2 high_res) + (supports camera2 low_res) + (visible_from objective0 waypoint0) + (visible_from objective0 waypoint1) + (visible_from objective0 waypoint2) + (visible_from objective0 waypoint3) + (visible_from objective1 waypoint0) + (visible_from objective1 waypoint1) + (visible_from objective1 waypoint2) + (visible_from objective2 waypoint0) + (visible_from objective2 waypoint1) + (visible_from objective2 waypoint2) +) + +(:goal (and +(communicated_soil_data waypoint1) +(communicated_soil_data waypoint2) +(communicated_rock_data waypoint0) +(communicated_rock_data waypoint1) +(communicated_image_data objective0 high_res) +(communicated_image_data objective2 high_res) +(communicated_image_data objective0 colour) + ) +) + +;(:metric minimize (recharges)) +) diff --git a/up_test_cases/performance/numeric/sailing/__init__.py b/up_test_cases/performance/numeric/sailing/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/numeric/sailing/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl new file mode 100755 index 000000000..c2738f3b0 --- /dev/null +++ b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl @@ -0,0 +1,54 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +;;Setting seed to 1229 +(define (problem instance_4_10_1229) + + (:domain sailing) + + (:objects + b0 b1 b2 b3 - boat + p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 - person + ) + + (:init + (= (x b0) -5) +(= (y b0) 0) +(= (x b1) 1) +(= (y b1) 0) +(= (x b2) -7) +(= (y b2) 0) +(= (x b3) 1) +(= (y b3) 0) + + + (= (d p0) -370) +(= (d p1) -58) +(= (d p2) 63) +(= (d p3) 483) +(= (d p4) 223) +(= (d p5) 316) +(= (d p6) -394) +(= (d p7) -242) +(= (d p8) -160) +(= (d p9) -338) + + + ) + + (:goal + (and + (saved p0) +(saved p1) +(saved p2) +(saved p3) +(saved p4) +(saved p5) +(saved p6) +(saved p7) +(saved p8) +(saved p9) + + ) + ) +) + + diff --git a/up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl new file mode 100755 index 000000000..1a57b8813 --- /dev/null +++ b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl @@ -0,0 +1,58 @@ +;; Enrico Scala (enricos83@gmail.com) and Miquel Ramirez (miquel.ramirez@gmail.com) +(define (domain sailing) + (:types boat -object person -object) + (:predicates + (saved ?t -person) + ) + (:functions + (x ?b -boat) + (y ?b -boat) + (d ?t -person) + ) + ;; Increment the value in the given counter by one + (:action go_north_east + :parameters (?b -boat) + + :effect (and(increase (x ?b) 1.5) (increase (y ?b) 1.5)) + ) + (:action go_north_west + :parameters (?b -boat) + + :effect (and(decrease (x ?b) 1.5) (increase (y ?b) 1.5)) + ) + (:action go_est + :parameters (?b -boat) + + :effect (and(increase (x ?b) 3)) + ) + (:action go_west + :parameters (?b -boat) + + :effect (and(decrease (x ?b) 3)) + ) + (:action go_south_west + :parameters(?b -boat) + + :effect (and(increase (x ?b) 2) (decrease (y ?b) 2)) + ) + (:action go_south_east + :parameters(?b -boat) + + :effect (and(decrease (x ?b) 2) (decrease (y ?b) 2)) + ) + (:action go_south + :parameters(?b -boat) + + :effect (and (decrease (y ?b) 2)) + ) + (:action save_person + :parameters(?b -boat ?t -person) + :precondition ( and (>= (+ (x ?b) (y ?b)) (d ?t)) + (>= (- (y ?b) (x ?b)) (d ?t)) + (<= (+ (x ?b) (y ?b)) (+ (d ?t) 25)) + (<= (- (y ?b) (x ?b)) (+ (d ?t) 25)) + ) + :effect (and(saved ?t)) + ) + +) diff --git a/up_test_cases/performance/temporal/__init__.py b/up_test_cases/performance/temporal/__init__.py new file mode 100644 index 000000000..60d697b5c --- /dev/null +++ b/up_test_cases/performance/temporal/__init__.py @@ -0,0 +1,4 @@ +from functools import partial +from utils import _get_test_cases # type: ignore + +get_test_cases = partial(_get_test_cases, "performance.temporal") diff --git a/up_test_cases/performance/temporal/depot/__init__.py b/up_test_cases/performance/temporal/depot/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/temporal/depot/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_domain.pddl b/up_test_cases/performance/temporal/depot/pddl_files/depots_domain.pddl new file mode 100644 index 000000000..7ea46f00d --- /dev/null +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_domain.pddl @@ -0,0 +1,52 @@ +(define (domain Depot) +(:requirements :typing :durative-actions :fluents) +(:types place locatable - object + depot distributor - place + truck hoist surface - locatable + pallet crate - surface) + +(:predicates (at ?x - locatable ?y - place) + (on ?x - crate ?y - surface) + (in ?x - crate ?y - truck) + (lifting ?x - hoist ?y - crate) + (available ?x - hoist) + (clear ?x - surface)) + +(:functions (distance ?x - place ?y - place) + (speed ?t - truck) + (weight ?c - crate) + (power ?h - hoist)) + +(:durative-action Drive +:parameters (?x - truck ?y - place ?z - place) +:duration (= ?duration (/ (distance ?y ?z) (speed ?x))) +:condition (and (at start (at ?x ?y))) +:effect (and (at start (not (at ?x ?y))) (at end (at ?x ?z)))) + +(:durative-action Lift +:parameters (?x - hoist ?y - crate ?z - surface ?p - place) +:duration (= ?duration 1) +:condition (and (over all (at ?x ?p)) (at start (available ?x)) (at start (at ?y ?p)) (at start (on ?y ?z)) (at start (clear ?y))) +:effect (and (at start (not (at ?y ?p))) (at start (lifting ?x ?y)) (at start (not (clear ?y))) (at start (not (available ?x))) + (at start (clear ?z)) (at start (not (on ?y ?z))))) + +(:durative-action Drop +:parameters (?x - hoist ?y - crate ?z - surface ?p - place) +:duration (= ?duration 1) +:condition (and (over all (at ?x ?p)) (over all (at ?z ?p)) (over all (clear ?z)) (over all (lifting ?x ?y))) +:effect (and (at end (available ?x)) (at end (not (lifting ?x ?y))) (at end (at ?y ?p)) (at end (not (clear ?z))) (at end (clear ?y)) + (at end (on ?y ?z)))) + +(:durative-action Load +:parameters (?x - hoist ?y - crate ?z - truck ?p - place) +:duration (= ?duration (/ (weight ?y) (power ?x))) +:condition (and (over all (at ?x ?p)) (over all (at ?z ?p)) (over all (lifting ?x ?y))) +:effect (and (at end (not (lifting ?x ?y))) (at end (in ?y ?z)) (at end (available ?x)))) + +(:durative-action Unload +:parameters (?x - hoist ?y - crate ?z - truck ?p - place) +:duration (= ?duration (/ (weight ?y) (power ?x))) +:condition (and (over all (at ?x ?p)) (over all (at ?z ?p)) (at start (available ?x)) (at start (in ?y ?z))) +:effect (and (at start (not (in ?y ?z))) (at start (not (available ?x))) (at start (lifting ?x ?y)))) + +) diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl new file mode 100644 index 000000000..50f647dc0 --- /dev/null +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl @@ -0,0 +1,109 @@ +(define (problem depotprob7654) (:domain Depot) +(:objects + depot0 depot1 depot2 - depot + distributor0 distributor1 distributor2 - distributor + truck0 truck1 - truck + pallet0 pallet1 pallet2 pallet3 pallet4 pallet5 - pallet + crate0 crate1 crate2 crate3 crate4 crate5 - crate + hoist0 hoist1 hoist2 hoist3 hoist4 hoist5 - hoist) +(:init + (at pallet0 depot0) + (clear crate1) + (at pallet1 depot1) + (clear crate0) + (at pallet2 depot2) + (clear crate4) + (at pallet3 distributor0) + (clear crate5) + (at pallet4 distributor1) + (clear pallet4) + (at pallet5 distributor2) + (clear crate3) + (at truck0 depot1) + (= (speed truck0) 3) + (at truck1 depot2) + (= (speed truck1) 2) + (at hoist0 depot0) + (available hoist0) + (= (power hoist0) 1) + (at hoist1 depot1) + (available hoist1) + (= (power hoist1) 6) + (at hoist2 depot2) + (available hoist2) + (= (power hoist2) 6) + (at hoist3 distributor0) + (available hoist3) + (= (power hoist3) 1) + (at hoist4 distributor1) + (available hoist4) + (= (power hoist4) 5) + (at hoist5 distributor2) + (available hoist5) + (= (power hoist5) 4) + (at crate0 depot1) + (on crate0 pallet1) + (= (weight crate0) 96) + (at crate1 depot0) + (on crate1 pallet0) + (= (weight crate1) 72) + (at crate2 distributor2) + (on crate2 pallet5) + (= (weight crate2) 74) + (at crate3 distributor2) + (on crate3 crate2) + (= (weight crate3) 16) + (at crate4 depot2) + (on crate4 pallet2) + (= (weight crate4) 23) + (at crate5 distributor0) + (on crate5 pallet3) + (= (weight crate5) 42) + (= (distance depot0 depot0) 0) + (= (distance depot0 depot1) 2) + (= (distance depot0 depot2) 10) + (= (distance depot0 distributor0) 6) + (= (distance depot0 distributor1) 1) + (= (distance depot0 distributor2) 7) + (= (distance depot1 depot0) 3) + (= (distance depot1 depot1) 0) + (= (distance depot1 depot2) 3) + (= (distance depot1 distributor0) 1) + (= (distance depot1 distributor1) 10) + (= (distance depot1 distributor2) 3) + (= (distance depot2 depot0) 7) + (= (distance depot2 depot1) 3) + (= (distance depot2 depot2) 0) + (= (distance depot2 distributor0) 7) + (= (distance depot2 distributor1) 2) + (= (distance depot2 distributor2) 4) + (= (distance distributor0 depot0) 4) + (= (distance distributor0 depot1) 10) + (= (distance distributor0 depot2) 6) + (= (distance distributor0 distributor0) 0) + (= (distance distributor0 distributor1) 8) + (= (distance distributor0 distributor2) 3) + (= (distance distributor1 depot0) 5) + (= (distance distributor1 depot1) 3) + (= (distance distributor1 depot2) 4) + (= (distance distributor1 distributor0) 3) + (= (distance distributor1 distributor1) 0) + (= (distance distributor1 distributor2) 10) + (= (distance distributor2 depot0) 7) + (= (distance distributor2 depot1) 6) + (= (distance distributor2 depot2) 1) + (= (distance distributor2 distributor0) 6) + (= (distance distributor2 distributor1) 2) + (= (distance distributor2 distributor2) 0) +) + +(:goal (and + (on crate0 crate4) + (on crate2 pallet3) + (on crate3 pallet0) + (on crate4 pallet5) + ) +) + +;(:metric minimize (total-time)) +) diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl new file mode 100644 index 000000000..fdc10a12d --- /dev/null +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl @@ -0,0 +1,127 @@ +(define (problem depotprob8765) (:domain Depot) +(:objects + depot0 depot1 depot2 - depot + distributor0 distributor1 distributor2 - distributor + truck0 truck1 - truck + pallet0 pallet1 pallet2 pallet3 pallet4 pallet5 - pallet + crate0 crate1 crate2 crate3 crate4 crate5 crate6 crate7 crate8 crate9 - crate + hoist0 hoist1 hoist2 hoist3 hoist4 hoist5 - hoist) +(:init + (at pallet0 depot0) + (clear crate1) + (at pallet1 depot1) + (clear crate3) + (at pallet2 depot2) + (clear crate9) + (at pallet3 distributor0) + (clear pallet3) + (at pallet4 distributor1) + (clear pallet4) + (at pallet5 distributor2) + (clear crate8) + (at truck0 depot2) + (= (speed truck0) 9) + (at truck1 distributor0) + (= (speed truck1) 9) + (at hoist0 depot0) + (available hoist0) + (= (power hoist0) 4) + (at hoist1 depot1) + (available hoist1) + (= (power hoist1) 3) + (at hoist2 depot2) + (available hoist2) + (= (power hoist2) 1) + (at hoist3 distributor0) + (available hoist3) + (= (power hoist3) 8) + (at hoist4 distributor1) + (available hoist4) + (= (power hoist4) 2) + (at hoist5 distributor2) + (available hoist5) + (= (power hoist5) 6) + (at crate0 depot1) + (on crate0 pallet1) + (= (weight crate0) 42) + (at crate1 depot0) + (on crate1 pallet0) + (= (weight crate1) 6) + (at crate2 depot2) + (on crate2 pallet2) + (= (weight crate2) 74) + (at crate3 depot1) + (on crate3 crate0) + (= (weight crate3) 64) + (at crate4 depot2) + (on crate4 crate2) + (= (weight crate4) 61) + (at crate5 depot2) + (on crate5 crate4) + (= (weight crate5) 79) + (at crate6 distributor2) + (on crate6 pallet5) + (= (weight crate6) 29) + (at crate7 distributor2) + (on crate7 crate6) + (= (weight crate7) 77) + (at crate8 distributor2) + (on crate8 crate7) + (= (weight crate8) 19) + (at crate9 depot2) + (on crate9 crate5) + (= (weight crate9) 98) + (= (distance depot0 depot0) 0) + (= (distance depot0 depot1) 1) + (= (distance depot0 depot2) 7) + (= (distance depot0 distributor0) 8) + (= (distance depot0 distributor1) 8) + (= (distance depot0 distributor2) 1) + (= (distance depot1 depot0) 9) + (= (distance depot1 depot1) 0) + (= (distance depot1 depot2) 2) + (= (distance depot1 distributor0) 7) + (= (distance depot1 distributor1) 10) + (= (distance depot1 distributor2) 6) + (= (distance depot2 depot0) 6) + (= (distance depot2 depot1) 9) + (= (distance depot2 depot2) 0) + (= (distance depot2 distributor0) 8) + (= (distance depot2 distributor1) 5) + (= (distance depot2 distributor2) 10) + (= (distance distributor0 depot0) 6) + (= (distance distributor0 depot1) 4) + (= (distance distributor0 depot2) 10) + (= (distance distributor0 distributor0) 0) + (= (distance distributor0 distributor1) 2) + (= (distance distributor0 distributor2) 7) + (= (distance distributor1 depot0) 2) + (= (distance distributor1 depot1) 9) + (= (distance distributor1 depot2) 10) + (= (distance distributor1 distributor0) 7) + (= (distance distributor1 distributor1) 0) + (= (distance distributor1 distributor2) 7) + (= (distance distributor2 depot0) 8) + (= (distance distributor2 depot1) 7) + (= (distance distributor2 depot2) 8) + (= (distance distributor2 distributor0) 5) + (= (distance distributor2 distributor1) 4) + (= (distance distributor2 distributor2) 0) +) + +(:goal (and + (on crate0 crate7) + (on crate1 pallet4) + (on crate2 pallet5) + (on crate3 crate9) + (on crate4 pallet0) + (on crate5 pallet2) + (on crate6 crate5) + (on crate7 crate1) + (on crate8 pallet3) + (on crate9 crate2) + ) +) + +;(:metric minimize (total-time)) +) From 1d4e644a3ee8749d3f89931670b2a2a19d70c5d1 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Wed, 8 Nov 2023 14:58:11 +0100 Subject: [PATCH 04/17] Updated result classes --- .../engines/oversubscription_planner.py | 1 - .../engines/pddl_anytime_planner.py | 1 - unified_planning/engines/pddl_planner.py | 8 ++--- unified_planning/engines/results.py | 8 ++--- .../grpc/generated/unified_planning_pb2.py | 36 +++++++++++-------- unified_planning/grpc/proto_reader.py | 14 ++++++-- unified_planning/grpc/proto_writer.py | 2 ++ unified_planning/grpc/unified_planning.proto | 6 ++++ up_test_cases/report.py | 12 +++---- 9 files changed, 53 insertions(+), 35 deletions(-) diff --git a/unified_planning/engines/oversubscription_planner.py b/unified_planning/engines/oversubscription_planner.py index 81db59fac..f66251f75 100644 --- a/unified_planning/engines/oversubscription_planner.py +++ b/unified_planning/engines/oversubscription_planner.py @@ -173,7 +173,6 @@ def _solve( self.name, metrics=res.metrics, log_messages=res.log_messages, - extra_engine_info=res.extra_engine_info, ) elif res.status == PlanGenerationResultStatus.TIMEOUT: return PlanGenerationResult( diff --git a/unified_planning/engines/pddl_anytime_planner.py b/unified_planning/engines/pddl_anytime_planner.py index 635b2d257..96ccbe64c 100644 --- a/unified_planning/engines/pddl_anytime_planner.py +++ b/unified_planning/engines/pddl_anytime_planner.py @@ -208,7 +208,6 @@ def _generate_last_result( solve_result.engine_name, solve_result.metrics, solve_result.log_messages, - solve_result.extra_engine_info, ) return res diff --git a/unified_planning/engines/pddl_planner.py b/unified_planning/engines/pddl_planner.py index d9f3974dc..beb6a6101 100644 --- a/unified_planning/engines/pddl_planner.py +++ b/unified_planning/engines/pddl_planner.py @@ -239,15 +239,15 @@ def _solve( plan = self._plan_from_file( problem, plan_filename, self._writer.get_item_named ) - extra_engine_info = {} - extra_engine_info["internal_time"] = str(process_end - process_start) + metrics = {} + metrics["engine_internal_time"] = str(process_end - process_start) if timeout_occurred and retval != 0: return PlanGenerationResult( PlanGenerationResultStatus.TIMEOUT, plan=plan, engine_name=self.name, log_messages=logs, - extra_engine_info=extra_engine_info, + metrics=metrics, ) status: PlanGenerationResultStatus = self._result_status( problem, plan, retval, logs @@ -257,7 +257,7 @@ def _solve( plan, engine_name=self.name, log_messages=logs, - extra_engine_info=extra_engine_info, + metrics=metrics, ) problem_kind = problem.kind if problem_kind.has_continuous_time() or problem_kind.has_discrete_time(): diff --git a/unified_planning/engines/results.py b/unified_planning/engines/results.py index ad40b32c8..007950e7d 100644 --- a/unified_planning/engines/results.py +++ b/unified_planning/engines/results.py @@ -145,7 +145,6 @@ class PlanGenerationResult(Result): engine_name: str metrics: Optional[Dict[str, str]] = field(default=None) log_messages: Optional[List[LogMessage]] = field(default=None) - extra_engine_info: Optional[Dict[str, str]] = field(default=None) def __post__init(self): # Checks that plan and status are consistent @@ -236,7 +235,6 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, - result.extra_engine_info, ) elif problem.epsilon is None or ( engine_epsilon is not None and problem.epsilon < engine_epsilon @@ -252,7 +250,6 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, - result.extra_engine_info, ) elif result.status == PlanGenerationResultStatus.SOLVED_OPTIMALLY: return PlanGenerationResult( @@ -261,7 +258,6 @@ def correct_plan_generation_result( result.engine_name, result.metrics, result.log_messages, - result.extra_engine_info, ) return result @@ -278,7 +274,7 @@ class ValidationResult(Result): ) reason: Optional[FailedValidationReason] = field(default=None) inapplicable_action: Optional[up.plans.ActionInstance] = field(default=None) - extra_engine_info: Optional[Dict[str, str]] = field(default=None) + metrics: Optional[Dict[str, str]] = field(default=None) def __post_init__(self): assert ( @@ -318,7 +314,7 @@ class CompilerResult(Result): ] engine_name: str log_messages: Optional[List[LogMessage]] = field(default=None) - extra_engine_info: Optional[Dict[str, str]] = field(default=None) + metrics: Optional[Dict[str, str]] = field(default=None) def _post_init(self): # Check that compiled problem and map_back_action_instance are consistent with each other diff --git a/unified_planning/grpc/generated/unified_planning_pb2.py b/unified_planning/grpc/generated/unified_planning_pb2.py index 166f5490e..560d84a37 100644 --- a/unified_planning/grpc/generated/unified_planning_pb2.py +++ b/unified_planning/grpc/generated/unified_planning_pb2.py @@ -13,7 +13,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16unified_planning.proto\"i\n\nExpression\x12\x13\n\x04\x61tom\x18\x01 \x01(\x0b\x32\x05.Atom\x12\x19\n\x04list\x18\x02 \x03(\x0b\x32\x0b.Expression\x12\x0c\n\x04type\x18\x03 \x01(\t\x12\x1d\n\x04kind\x18\x04 \x01(\x0e\x32\x0f.ExpressionKind\"\\\n\x04\x41tom\x12\x10\n\x06symbol\x18\x01 \x01(\tH\x00\x12\r\n\x03int\x18\x02 \x01(\x03H\x00\x12\x15\n\x04real\x18\x03 \x01(\x0b\x32\x05.RealH\x00\x12\x11\n\x07\x62oolean\x18\x04 \x01(\x08H\x00\x42\t\n\x07\x63ontent\".\n\x04Real\x12\x11\n\tnumerator\x18\x01 \x01(\x03\x12\x13\n\x0b\x64\x65nominator\x18\x02 \x01(\x03\"9\n\x0fTypeDeclaration\x12\x11\n\ttype_name\x18\x01 \x01(\t\x12\x13\n\x0bparent_type\x18\x02 \x01(\t\"\'\n\tParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"n\n\x06\x46luent\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x12\n\nvalue_type\x18\x02 \x01(\t\x12\x1e\n\nparameters\x18\x03 \x03(\x0b\x32\n.Parameter\x12\"\n\rdefault_value\x18\x04 \x01(\x0b\x32\x0b.Expression\"/\n\x11ObjectDeclaration\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"\xea\x01\n\x10\x45\x66\x66\x65\x63tExpression\x12*\n\x04kind\x18\x01 \x01(\x0e\x32\x1c.EffectExpression.EffectKind\x12\x1b\n\x06\x66luent\x18\x02 \x01(\x0b\x32\x0b.Expression\x12\x1a\n\x05value\x18\x03 \x01(\x0b\x32\x0b.Expression\x12\x1e\n\tcondition\x18\x04 \x01(\x0b\x32\x0b.Expression\x12\x1b\n\x06\x66orall\x18\x05 \x03(\x0b\x32\x0b.Expression\"4\n\nEffectKind\x12\n\n\x06\x41SSIGN\x10\x00\x12\x0c\n\x08INCREASE\x10\x01\x12\x0c\n\x08\x44\x45\x43REASE\x10\x02\"M\n\x06\x45\x66\x66\x65\x63t\x12!\n\x06\x65\x66\x66\x65\x63t\x18\x01 \x01(\x0b\x32\x11.EffectExpression\x12 \n\x0foccurrence_time\x18\x02 \x01(\x0b\x32\x07.Timing\"C\n\tCondition\x12\x19\n\x04\x63ond\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1b\n\x04span\x18\x02 \x01(\x0b\x32\r.TimeInterval\"\x8d\x01\n\x06\x41\x63tion\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1b\n\x08\x64uration\x18\x03 \x01(\x0b\x32\t.Duration\x12\x1e\n\nconditions\x18\x04 \x03(\x0b\x32\n.Condition\x12\x18\n\x07\x65\x66\x66\x65\x63ts\x18\x05 \x03(\x0b\x32\x07.Effect\"\x90\x01\n\tTimepoint\x12&\n\x04kind\x18\x01 \x01(\x0e\x32\x18.Timepoint.TimepointKind\x12\x14\n\x0c\x63ontainer_id\x18\x02 \x01(\t\"E\n\rTimepointKind\x12\x10\n\x0cGLOBAL_START\x10\x00\x12\x0e\n\nGLOBAL_END\x10\x01\x12\t\n\x05START\x10\x02\x12\x07\n\x03\x45ND\x10\x03\"=\n\x06Timing\x12\x1d\n\ttimepoint\x18\x01 \x01(\x0b\x32\n.Timepoint\x12\x14\n\x05\x64\x65lay\x18\x02 \x01(\x0b\x32\x05.Real\"o\n\x08Interval\x12\x14\n\x0cis_left_open\x18\x01 \x01(\x08\x12\x1a\n\x05lower\x18\x02 \x01(\x0b\x32\x0b.Expression\x12\x15\n\ris_right_open\x18\x03 \x01(\x08\x12\x1a\n\x05upper\x18\x04 \x01(\x0b\x32\x0b.Expression\"k\n\x0cTimeInterval\x12\x14\n\x0cis_left_open\x18\x01 \x01(\x08\x12\x16\n\x05lower\x18\x02 \x01(\x0b\x32\x07.Timing\x12\x15\n\ris_right_open\x18\x03 \x01(\x08\x12\x16\n\x05upper\x18\x04 \x01(\x0b\x32\x07.Timing\"5\n\x08\x44uration\x12)\n\x16\x63ontrollable_in_bounds\x18\x01 \x01(\x0b\x32\t.Interval\"G\n\x17\x41\x62stractTaskDeclaration\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\"F\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x11\n\ttask_name\x18\x02 \x01(\t\x12\x1f\n\nparameters\x18\x03 \x03(\x0b\x32\x0b.Expression\"\xaf\x01\n\x06Method\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1c\n\rachieved_task\x18\x03 \x01(\x0b\x32\x05.Task\x12\x17\n\x08subtasks\x18\x04 \x03(\x0b\x32\x05.Task\x12 \n\x0b\x63onstraints\x18\x05 \x03(\x0b\x32\x0b.Expression\x12\x1e\n\nconditions\x18\x06 \x03(\x0b\x32\n.Condition\"g\n\x0bTaskNetwork\x12\x1d\n\tvariables\x18\x01 \x03(\x0b\x32\n.Parameter\x12\x17\n\x08subtasks\x18\x02 \x03(\x0b\x32\x05.Task\x12 \n\x0b\x63onstraints\x18\x03 \x03(\x0b\x32\x0b.Expression\"\x83\x01\n\tHierarchy\x12\x30\n\x0e\x61\x62stract_tasks\x18\x01 \x03(\x0b\x32\x18.AbstractTaskDeclaration\x12\x18\n\x07methods\x18\x02 \x03(\x0b\x32\x07.Method\x12*\n\x14initial_task_network\x18\x03 \x01(\x0b\x32\x0c.TaskNetwork\"\xb1\x01\n\x08\x41\x63tivity\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1b\n\x08\x64uration\x18\x03 \x01(\x0b\x32\t.Duration\x12\x1e\n\nconditions\x18\x04 \x03(\x0b\x32\n.Condition\x12\x18\n\x07\x65\x66\x66\x65\x63ts\x18\x05 \x03(\x0b\x32\x07.Effect\x12 \n\x0b\x63onstraints\x18\x06 \x03(\x0b\x32\x0b.Expression\"u\n\x13SchedulingExtension\x12\x1d\n\nactivities\x18\x01 \x03(\x0b\x32\t.Activity\x12\x1d\n\tvariables\x18\x02 \x03(\x0b\x32\n.Parameter\x12 \n\x0b\x63onstraints\x18\x05 \x03(\x0b\x32\x0b.Expression\"\xa3\x01\n\x08Schedule\x12\x12\n\nactivities\x18\x01 \x03(\t\x12@\n\x14variable_assignments\x18\x02 \x03(\x0b\x32\".Schedule.VariableAssignmentsEntry\x1a\x41\n\x18VariableAssignmentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x14\n\x05value\x18\x02 \x01(\x0b\x32\x05.Atom:\x02\x38\x01\"@\n\x04Goal\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1d\n\x06timing\x18\x02 \x01(\x0b\x32\r.TimeInterval\"R\n\x0bTimedEffect\x12!\n\x06\x65\x66\x66\x65\x63t\x18\x01 \x01(\x0b\x32\x11.EffectExpression\x12 \n\x0foccurrence_time\x18\x02 \x01(\x0b\x32\x07.Timing\"E\n\nAssignment\x12\x1b\n\x06\x66luent\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1a\n\x05value\x18\x02 \x01(\x0b\x32\x0b.Expression\"B\n\x0eGoalWithWeight\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x15\n\x06weight\x18\x02 \x01(\x0b\x32\x05.Real\"f\n\x13TimedGoalWithWeight\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1d\n\x06timing\x18\x02 \x01(\x0b\x32\r.TimeInterval\x12\x15\n\x06weight\x18\x03 \x01(\x0b\x32\x05.Real\"\x9c\x04\n\x06Metric\x12 \n\x04kind\x18\x01 \x01(\x0e\x32\x12.Metric.MetricKind\x12\x1f\n\nexpression\x18\x02 \x01(\x0b\x32\x0b.Expression\x12.\n\x0c\x61\x63tion_costs\x18\x03 \x03(\x0b\x32\x18.Metric.ActionCostsEntry\x12(\n\x13\x64\x65\x66\x61ult_action_cost\x18\x04 \x01(\x0b\x32\x0b.Expression\x12\x1e\n\x05goals\x18\x05 \x03(\x0b\x32\x0f.GoalWithWeight\x12)\n\x0btimed_goals\x18\x06 \x03(\x0b\x32\x14.TimedGoalWithWeight\x1a?\n\x10\x41\x63tionCostsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1a\n\x05value\x18\x02 \x01(\x0b\x32\x0b.Expression:\x02\x38\x01\"\xe8\x01\n\nMetricKind\x12\x19\n\x15MINIMIZE_ACTION_COSTS\x10\x00\x12#\n\x1fMINIMIZE_SEQUENTIAL_PLAN_LENGTH\x10\x01\x12\x15\n\x11MINIMIZE_MAKESPAN\x10\x02\x12&\n\"MINIMIZE_EXPRESSION_ON_FINAL_STATE\x10\x03\x12&\n\"MAXIMIZE_EXPRESSION_ON_FINAL_STATE\x10\x04\x12\x14\n\x10OVERSUBSCRIPTION\x10\x05\x12\x1d\n\x19TEMPORAL_OVERSUBSCRIPTION\x10\x06\"\x8c\x04\n\x07Problem\x12\x13\n\x0b\x64omain_name\x18\x01 \x01(\t\x12\x14\n\x0cproblem_name\x18\x02 \x01(\t\x12\x1f\n\x05types\x18\x03 \x03(\x0b\x32\x10.TypeDeclaration\x12\x18\n\x07\x66luents\x18\x04 \x03(\x0b\x32\x07.Fluent\x12#\n\x07objects\x18\x05 \x03(\x0b\x32\x12.ObjectDeclaration\x12\x18\n\x07\x61\x63tions\x18\x06 \x03(\x0b\x32\x07.Action\x12\"\n\rinitial_state\x18\x07 \x03(\x0b\x32\x0b.Assignment\x12#\n\rtimed_effects\x18\x08 \x03(\x0b\x32\x0c.TimedEffect\x12\x14\n\x05goals\x18\t \x03(\x0b\x32\x05.Goal\x12\x1a\n\x08\x66\x65\x61tures\x18\n \x03(\x0e\x32\x08.Feature\x12\x18\n\x07metrics\x18\x0b \x03(\x0b\x32\x07.Metric\x12\x1d\n\thierarchy\x18\x0c \x01(\x0b\x32\n.Hierarchy\x12\x32\n\x14scheduling_extension\x18\x11 \x01(\x0b\x32\x14.SchedulingExtension\x12+\n\x16trajectory_constraints\x18\r \x03(\x0b\x32\x0b.Expression\x12\x15\n\rdiscrete_time\x18\x0e \x01(\x08\x12\x18\n\x10self_overlapping\x18\x0f \x01(\x08\x12\x16\n\x07\x65psilon\x18\x10 \x01(\x0b\x32\x05.Real\"\x80\x01\n\x0e\x41\x63tionInstance\x12\n\n\x02id\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tion_name\x18\x02 \x01(\t\x12\x19\n\nparameters\x18\x03 \x03(\x0b\x32\x05.Atom\x12\x19\n\nstart_time\x18\x04 \x01(\x0b\x32\x05.Real\x12\x17\n\x08\x65nd_time\x18\x05 \x01(\x0b\x32\x05.Real\"\xae\x01\n\x0eMethodInstance\x12\n\n\x02id\x18\x01 \x01(\t\x12\x13\n\x0bmethod_name\x18\x02 \x01(\t\x12\x19\n\nparameters\x18\x03 \x03(\x0b\x32\x05.Atom\x12/\n\x08subtasks\x18\x06 \x03(\x0b\x32\x1d.MethodInstance.SubtasksEntry\x1a/\n\rSubtasksEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x96\x01\n\rPlanHierarchy\x12\x31\n\nroot_tasks\x18\x01 \x03(\x0b\x32\x1d.PlanHierarchy.RootTasksEntry\x12 \n\x07methods\x18\x02 \x03(\x0b\x32\x0f.MethodInstance\x1a\x30\n\x0eRootTasksEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"h\n\x04Plan\x12 \n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x0f.ActionInstance\x12!\n\thierarchy\x18\x02 \x01(\x0b\x32\x0e.PlanHierarchy\x12\x1b\n\x08schedule\x18\x03 \x01(\x0b\x32\t.Schedule\"\x83\x02\n\x0bPlanRequest\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12*\n\x0fresolution_mode\x18\x02 \x01(\x0e\x32\x11.PlanRequest.Mode\x12\x0f\n\x07timeout\x18\x03 \x01(\x01\x12\x37\n\x0e\x65ngine_options\x18\x04 \x03(\x0b\x32\x1f.PlanRequest.EngineOptionsEntry\x1a\x34\n\x12\x45ngineOptionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"-\n\x04Mode\x12\x0f\n\x0bSATISFIABLE\x10\x00\x12\x14\n\x10SOLVED_OPTIMALLY\x10\x01\"C\n\x11ValidationRequest\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12\x13\n\x04plan\x18\x02 \x01(\x0b\x32\x05.Plan\"{\n\nLogMessage\x12#\n\x05level\x18\x01 \x01(\x0e\x32\x14.LogMessage.LogLevel\x12\x0f\n\x07message\x18\x02 \x01(\t\"7\n\x08LogLevel\x12\t\n\x05\x44\x45\x42UG\x10\x00\x12\x08\n\x04INFO\x10\x01\x12\x0b\n\x07WARNING\x10\x02\x12\t\n\x05\x45RROR\x10\x03\"\xbf\x03\n\x14PlanGenerationResult\x12,\n\x06status\x18\x01 \x01(\x0e\x32\x1c.PlanGenerationResult.Status\x12\x13\n\x04plan\x18\x02 \x01(\x0b\x32\x05.Plan\x12\x33\n\x07metrics\x18\x03 \x03(\x0b\x32\".PlanGenerationResult.MetricsEntry\x12!\n\x0clog_messages\x18\x04 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x05 \x01(\x0b\x32\x07.Engine\x1a.\n\x0cMetricsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xc2\x01\n\x06Status\x12\x16\n\x12SOLVED_SATISFICING\x10\x00\x12\x14\n\x10SOLVED_OPTIMALLY\x10\x01\x12\x15\n\x11UNSOLVABLE_PROVEN\x10\x02\x12\x1b\n\x17UNSOLVABLE_INCOMPLETELY\x10\x03\x12\x0b\n\x07TIMEOUT\x10\r\x12\n\n\x06MEMOUT\x10\x0e\x12\x12\n\x0eINTERNAL_ERROR\x10\x0f\x12\x17\n\x13UNSUPPORTED_PROBLEM\x10\x10\x12\x10\n\x0cINTERMEDIATE\x10\x11\"\x16\n\x06\x45ngine\x12\x0c\n\x04name\x18\x01 \x01(\t\"\xc7\x01\n\x10ValidationResult\x12\x38\n\x06status\x18\x01 \x01(\x0e\x32(.ValidationResult.ValidationResultStatus\x12!\n\x0clog_messages\x18\x02 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x03 \x01(\x0b\x32\x07.Engine\"=\n\x16ValidationResultStatus\x12\t\n\x05VALID\x10\x00\x12\x0b\n\x07INVALID\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\"\xe5\x01\n\x0e\x43ompilerResult\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12\x37\n\rmap_back_plan\x18\x02 \x03(\x0b\x32 .CompilerResult.MapBackPlanEntry\x12!\n\x0clog_messages\x18\x03 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x04 \x01(\x0b\x32\x07.Engine\x1a\x43\n\x10MapBackPlanEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1e\n\x05value\x18\x02 \x01(\x0b\x32\x0f.ActionInstance:\x02\x38\x01*\xb0\x01\n\x0e\x45xpressionKind\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0c\n\x08\x43ONSTANT\x10\x01\x12\r\n\tPARAMETER\x10\x02\x12\x0c\n\x08VARIABLE\x10\x07\x12\x11\n\rFLUENT_SYMBOL\x10\x03\x12\x13\n\x0f\x46UNCTION_SYMBOL\x10\x04\x12\x12\n\x0eSTATE_VARIABLE\x10\x05\x12\x18\n\x14\x46UNCTION_APPLICATION\x10\x06\x12\x10\n\x0c\x43ONTAINER_ID\x10\x08*\x96\x0e\n\x07\x46\x65\x61ture\x12\x10\n\x0c\x41\x43TION_BASED\x10\x00\x12\x10\n\x0cHIERARCHICAL\x10\x1a\x12\x0e\n\nSCHEDULING\x10\x38\x12\x1b\n\x17SIMPLE_NUMERIC_PLANNING\x10\x1e\x12\x1c\n\x18GENERAL_NUMERIC_PLANNING\x10\x1f\x12\x13\n\x0f\x43ONTINUOUS_TIME\x10\x01\x12\x11\n\rDISCRETE_TIME\x10\x02\x12\'\n#INTERMEDIATE_CONDITIONS_AND_EFFECTS\x10\x03\x12#\n\x1f\x45XTERNAL_CONDITIONS_AND_EFFECTS\x10\'\x12\x11\n\rTIMED_EFFECTS\x10\x04\x12\x0f\n\x0bTIMED_GOALS\x10\x05\x12\x19\n\x15\x44URATION_INEQUALITIES\x10\x06\x12\x14\n\x10SELF_OVERLAPPING\x10/\x12\x1f\n\x1bSTATIC_FLUENTS_IN_DURATIONS\x10\x1b\x12\x18\n\x14\x46LUENTS_IN_DURATIONS\x10\x1c\x12\x17\n\x13REAL_TYPE_DURATIONS\x10>\x12\x16\n\x12INT_TYPE_DURATIONS\x10?\x12\x16\n\x12\x43ONTINUOUS_NUMBERS\x10\x07\x12\x14\n\x10\x44ISCRETE_NUMBERS\x10\x08\x12\x11\n\rBOUNDED_TYPES\x10&\x12\x17\n\x13NEGATIVE_CONDITIONS\x10\t\x12\x1a\n\x16\x44ISJUNCTIVE_CONDITIONS\x10\n\x12\x0e\n\nEQUALITIES\x10\x0b\x12\x1a\n\x16\x45XISTENTIAL_CONDITIONS\x10\x0c\x12\x18\n\x14UNIVERSAL_CONDITIONS\x10\r\x12\x17\n\x13\x43ONDITIONAL_EFFECTS\x10\x0e\x12\x14\n\x10INCREASE_EFFECTS\x10\x0f\x12\x14\n\x10\x44\x45\x43REASE_EFFECTS\x10\x10\x12)\n%STATIC_FLUENTS_IN_BOOLEAN_ASSIGNMENTS\x10)\x12)\n%STATIC_FLUENTS_IN_NUMERIC_ASSIGNMENTS\x10*\x12(\n$STATIC_FLUENTS_IN_OBJECT_ASSIGNMENTS\x10\x39\x12\"\n\x1e\x46LUENTS_IN_BOOLEAN_ASSIGNMENTS\x10+\x12\"\n\x1e\x46LUENTS_IN_NUMERIC_ASSIGNMENTS\x10,\x12!\n\x1d\x46LUENTS_IN_OBJECT_ASSIGNMENTS\x10:\x12\x12\n\x0e\x46ORALL_EFFECTS\x10;\x12\x0f\n\x0b\x46LAT_TYPING\x10\x11\x12\x17\n\x13HIERARCHICAL_TYPING\x10\x12\x12\x13\n\x0fNUMERIC_FLUENTS\x10\x13\x12\x12\n\x0eOBJECT_FLUENTS\x10\x14\x12\x0f\n\x0bINT_FLUENTS\x10<\x12\x10\n\x0cREAL_FLUENTS\x10=\x12\x1a\n\x16\x42OOL_FLUENT_PARAMETERS\x10\x32\x12!\n\x1d\x42OUNDED_INT_FLUENT_PARAMETERS\x10\x33\x12\x1a\n\x16\x42OOL_ACTION_PARAMETERS\x10\x34\x12!\n\x1d\x42OUNDED_INT_ACTION_PARAMETERS\x10\x35\x12#\n\x1fUNBOUNDED_INT_ACTION_PARAMETERS\x10\x36\x12\x1a\n\x16REAL_ACTION_PARAMETERS\x10\x37\x12\x10\n\x0c\x41\x43TIONS_COST\x10\x15\x12\x0f\n\x0b\x46INAL_VALUE\x10\x16\x12\x0c\n\x08MAKESPAN\x10\x17\x12\x0f\n\x0bPLAN_LENGTH\x10\x18\x12\x14\n\x10OVERSUBSCRIPTION\x10\x1d\x12\x1d\n\x19TEMPORAL_OVERSUBSCRIPTION\x10(\x12\"\n\x1eSTATIC_FLUENTS_IN_ACTIONS_COST\x10-\x12\x1b\n\x17\x46LUENTS_IN_ACTIONS_COST\x10.\x12 \n\x1cREAL_NUMBERS_IN_ACTIONS_COST\x10@\x12\x1f\n\x1bINT_NUMBERS_IN_ACTIONS_COST\x10\x41\x12$\n REAL_NUMBERS_IN_OVERSUBSCRIPTION\x10\x42\x12#\n\x1fINT_NUMBERS_IN_OVERSUBSCRIPTION\x10\x43\x12\x15\n\x11SIMULATED_EFFECTS\x10\x19\x12\x1a\n\x16TRAJECTORY_CONSTRAINTS\x10\x30\x12\x14\n\x10STATE_INVARIANTS\x10\x31\x12\x18\n\x14METHOD_PRECONDITIONS\x10 \x12\x1c\n\x18TASK_NETWORK_CONSTRAINTS\x10!\x12\"\n\x1eINITIAL_TASK_NETWORK_VARIABLES\x10\"\x12\x14\n\x10TASK_ORDER_TOTAL\x10#\x12\x16\n\x12TASK_ORDER_PARTIAL\x10$\x12\x17\n\x13TASK_ORDER_TEMPORAL\x10%2\xd8\x01\n\x0fUnifiedPlanning\x12\x34\n\x0bplanAnytime\x12\x0c.PlanRequest\x1a\x15.PlanGenerationResult0\x01\x12\x32\n\x0bplanOneShot\x12\x0c.PlanRequest\x1a\x15.PlanGenerationResult\x12\x35\n\x0cvalidatePlan\x12\x12.ValidationRequest\x1a\x11.ValidationResult\x12$\n\x07\x63ompile\x12\x08.Problem\x1a\x0f.CompilerResultb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16unified_planning.proto\"i\n\nExpression\x12\x13\n\x04\x61tom\x18\x01 \x01(\x0b\x32\x05.Atom\x12\x19\n\x04list\x18\x02 \x03(\x0b\x32\x0b.Expression\x12\x0c\n\x04type\x18\x03 \x01(\t\x12\x1d\n\x04kind\x18\x04 \x01(\x0e\x32\x0f.ExpressionKind\"\\\n\x04\x41tom\x12\x10\n\x06symbol\x18\x01 \x01(\tH\x00\x12\r\n\x03int\x18\x02 \x01(\x03H\x00\x12\x15\n\x04real\x18\x03 \x01(\x0b\x32\x05.RealH\x00\x12\x11\n\x07\x62oolean\x18\x04 \x01(\x08H\x00\x42\t\n\x07\x63ontent\".\n\x04Real\x12\x11\n\tnumerator\x18\x01 \x01(\x03\x12\x13\n\x0b\x64\x65nominator\x18\x02 \x01(\x03\"9\n\x0fTypeDeclaration\x12\x11\n\ttype_name\x18\x01 \x01(\t\x12\x13\n\x0bparent_type\x18\x02 \x01(\t\"\'\n\tParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"n\n\x06\x46luent\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x12\n\nvalue_type\x18\x02 \x01(\t\x12\x1e\n\nparameters\x18\x03 \x03(\x0b\x32\n.Parameter\x12\"\n\rdefault_value\x18\x04 \x01(\x0b\x32\x0b.Expression\"/\n\x11ObjectDeclaration\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"\xea\x01\n\x10\x45\x66\x66\x65\x63tExpression\x12*\n\x04kind\x18\x01 \x01(\x0e\x32\x1c.EffectExpression.EffectKind\x12\x1b\n\x06\x66luent\x18\x02 \x01(\x0b\x32\x0b.Expression\x12\x1a\n\x05value\x18\x03 \x01(\x0b\x32\x0b.Expression\x12\x1e\n\tcondition\x18\x04 \x01(\x0b\x32\x0b.Expression\x12\x1b\n\x06\x66orall\x18\x05 \x03(\x0b\x32\x0b.Expression\"4\n\nEffectKind\x12\n\n\x06\x41SSIGN\x10\x00\x12\x0c\n\x08INCREASE\x10\x01\x12\x0c\n\x08\x44\x45\x43REASE\x10\x02\"M\n\x06\x45\x66\x66\x65\x63t\x12!\n\x06\x65\x66\x66\x65\x63t\x18\x01 \x01(\x0b\x32\x11.EffectExpression\x12 \n\x0foccurrence_time\x18\x02 \x01(\x0b\x32\x07.Timing\"C\n\tCondition\x12\x19\n\x04\x63ond\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1b\n\x04span\x18\x02 \x01(\x0b\x32\r.TimeInterval\"\x8d\x01\n\x06\x41\x63tion\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1b\n\x08\x64uration\x18\x03 \x01(\x0b\x32\t.Duration\x12\x1e\n\nconditions\x18\x04 \x03(\x0b\x32\n.Condition\x12\x18\n\x07\x65\x66\x66\x65\x63ts\x18\x05 \x03(\x0b\x32\x07.Effect\"\x90\x01\n\tTimepoint\x12&\n\x04kind\x18\x01 \x01(\x0e\x32\x18.Timepoint.TimepointKind\x12\x14\n\x0c\x63ontainer_id\x18\x02 \x01(\t\"E\n\rTimepointKind\x12\x10\n\x0cGLOBAL_START\x10\x00\x12\x0e\n\nGLOBAL_END\x10\x01\x12\t\n\x05START\x10\x02\x12\x07\n\x03\x45ND\x10\x03\"=\n\x06Timing\x12\x1d\n\ttimepoint\x18\x01 \x01(\x0b\x32\n.Timepoint\x12\x14\n\x05\x64\x65lay\x18\x02 \x01(\x0b\x32\x05.Real\"o\n\x08Interval\x12\x14\n\x0cis_left_open\x18\x01 \x01(\x08\x12\x1a\n\x05lower\x18\x02 \x01(\x0b\x32\x0b.Expression\x12\x15\n\ris_right_open\x18\x03 \x01(\x08\x12\x1a\n\x05upper\x18\x04 \x01(\x0b\x32\x0b.Expression\"k\n\x0cTimeInterval\x12\x14\n\x0cis_left_open\x18\x01 \x01(\x08\x12\x16\n\x05lower\x18\x02 \x01(\x0b\x32\x07.Timing\x12\x15\n\ris_right_open\x18\x03 \x01(\x08\x12\x16\n\x05upper\x18\x04 \x01(\x0b\x32\x07.Timing\"5\n\x08\x44uration\x12)\n\x16\x63ontrollable_in_bounds\x18\x01 \x01(\x0b\x32\t.Interval\"G\n\x17\x41\x62stractTaskDeclaration\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\"F\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x11\n\ttask_name\x18\x02 \x01(\t\x12\x1f\n\nparameters\x18\x03 \x03(\x0b\x32\x0b.Expression\"\xaf\x01\n\x06Method\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1c\n\rachieved_task\x18\x03 \x01(\x0b\x32\x05.Task\x12\x17\n\x08subtasks\x18\x04 \x03(\x0b\x32\x05.Task\x12 \n\x0b\x63onstraints\x18\x05 \x03(\x0b\x32\x0b.Expression\x12\x1e\n\nconditions\x18\x06 \x03(\x0b\x32\n.Condition\"g\n\x0bTaskNetwork\x12\x1d\n\tvariables\x18\x01 \x03(\x0b\x32\n.Parameter\x12\x17\n\x08subtasks\x18\x02 \x03(\x0b\x32\x05.Task\x12 \n\x0b\x63onstraints\x18\x03 \x03(\x0b\x32\x0b.Expression\"\x83\x01\n\tHierarchy\x12\x30\n\x0e\x61\x62stract_tasks\x18\x01 \x03(\x0b\x32\x18.AbstractTaskDeclaration\x12\x18\n\x07methods\x18\x02 \x03(\x0b\x32\x07.Method\x12*\n\x14initial_task_network\x18\x03 \x01(\x0b\x32\x0c.TaskNetwork\"\xb1\x01\n\x08\x41\x63tivity\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\nparameters\x18\x02 \x03(\x0b\x32\n.Parameter\x12\x1b\n\x08\x64uration\x18\x03 \x01(\x0b\x32\t.Duration\x12\x1e\n\nconditions\x18\x04 \x03(\x0b\x32\n.Condition\x12\x18\n\x07\x65\x66\x66\x65\x63ts\x18\x05 \x03(\x0b\x32\x07.Effect\x12 \n\x0b\x63onstraints\x18\x06 \x03(\x0b\x32\x0b.Expression\"u\n\x13SchedulingExtension\x12\x1d\n\nactivities\x18\x01 \x03(\x0b\x32\t.Activity\x12\x1d\n\tvariables\x18\x02 \x03(\x0b\x32\n.Parameter\x12 \n\x0b\x63onstraints\x18\x05 \x03(\x0b\x32\x0b.Expression\"\xa3\x01\n\x08Schedule\x12\x12\n\nactivities\x18\x01 \x03(\t\x12@\n\x14variable_assignments\x18\x02 \x03(\x0b\x32\".Schedule.VariableAssignmentsEntry\x1a\x41\n\x18VariableAssignmentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x14\n\x05value\x18\x02 \x01(\x0b\x32\x05.Atom:\x02\x38\x01\"@\n\x04Goal\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1d\n\x06timing\x18\x02 \x01(\x0b\x32\r.TimeInterval\"R\n\x0bTimedEffect\x12!\n\x06\x65\x66\x66\x65\x63t\x18\x01 \x01(\x0b\x32\x11.EffectExpression\x12 \n\x0foccurrence_time\x18\x02 \x01(\x0b\x32\x07.Timing\"E\n\nAssignment\x12\x1b\n\x06\x66luent\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1a\n\x05value\x18\x02 \x01(\x0b\x32\x0b.Expression\"B\n\x0eGoalWithWeight\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x15\n\x06weight\x18\x02 \x01(\x0b\x32\x05.Real\"f\n\x13TimedGoalWithWeight\x12\x19\n\x04goal\x18\x01 \x01(\x0b\x32\x0b.Expression\x12\x1d\n\x06timing\x18\x02 \x01(\x0b\x32\r.TimeInterval\x12\x15\n\x06weight\x18\x03 \x01(\x0b\x32\x05.Real\"\x9c\x04\n\x06Metric\x12 \n\x04kind\x18\x01 \x01(\x0e\x32\x12.Metric.MetricKind\x12\x1f\n\nexpression\x18\x02 \x01(\x0b\x32\x0b.Expression\x12.\n\x0c\x61\x63tion_costs\x18\x03 \x03(\x0b\x32\x18.Metric.ActionCostsEntry\x12(\n\x13\x64\x65\x66\x61ult_action_cost\x18\x04 \x01(\x0b\x32\x0b.Expression\x12\x1e\n\x05goals\x18\x05 \x03(\x0b\x32\x0f.GoalWithWeight\x12)\n\x0btimed_goals\x18\x06 \x03(\x0b\x32\x14.TimedGoalWithWeight\x1a?\n\x10\x41\x63tionCostsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1a\n\x05value\x18\x02 \x01(\x0b\x32\x0b.Expression:\x02\x38\x01\"\xe8\x01\n\nMetricKind\x12\x19\n\x15MINIMIZE_ACTION_COSTS\x10\x00\x12#\n\x1fMINIMIZE_SEQUENTIAL_PLAN_LENGTH\x10\x01\x12\x15\n\x11MINIMIZE_MAKESPAN\x10\x02\x12&\n\"MINIMIZE_EXPRESSION_ON_FINAL_STATE\x10\x03\x12&\n\"MAXIMIZE_EXPRESSION_ON_FINAL_STATE\x10\x04\x12\x14\n\x10OVERSUBSCRIPTION\x10\x05\x12\x1d\n\x19TEMPORAL_OVERSUBSCRIPTION\x10\x06\"\x8c\x04\n\x07Problem\x12\x13\n\x0b\x64omain_name\x18\x01 \x01(\t\x12\x14\n\x0cproblem_name\x18\x02 \x01(\t\x12\x1f\n\x05types\x18\x03 \x03(\x0b\x32\x10.TypeDeclaration\x12\x18\n\x07\x66luents\x18\x04 \x03(\x0b\x32\x07.Fluent\x12#\n\x07objects\x18\x05 \x03(\x0b\x32\x12.ObjectDeclaration\x12\x18\n\x07\x61\x63tions\x18\x06 \x03(\x0b\x32\x07.Action\x12\"\n\rinitial_state\x18\x07 \x03(\x0b\x32\x0b.Assignment\x12#\n\rtimed_effects\x18\x08 \x03(\x0b\x32\x0c.TimedEffect\x12\x14\n\x05goals\x18\t \x03(\x0b\x32\x05.Goal\x12\x1a\n\x08\x66\x65\x61tures\x18\n \x03(\x0e\x32\x08.Feature\x12\x18\n\x07metrics\x18\x0b \x03(\x0b\x32\x07.Metric\x12\x1d\n\thierarchy\x18\x0c \x01(\x0b\x32\n.Hierarchy\x12\x32\n\x14scheduling_extension\x18\x11 \x01(\x0b\x32\x14.SchedulingExtension\x12+\n\x16trajectory_constraints\x18\r \x03(\x0b\x32\x0b.Expression\x12\x15\n\rdiscrete_time\x18\x0e \x01(\x08\x12\x18\n\x10self_overlapping\x18\x0f \x01(\x08\x12\x16\n\x07\x65psilon\x18\x10 \x01(\x0b\x32\x05.Real\"\x80\x01\n\x0e\x41\x63tionInstance\x12\n\n\x02id\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tion_name\x18\x02 \x01(\t\x12\x19\n\nparameters\x18\x03 \x03(\x0b\x32\x05.Atom\x12\x19\n\nstart_time\x18\x04 \x01(\x0b\x32\x05.Real\x12\x17\n\x08\x65nd_time\x18\x05 \x01(\x0b\x32\x05.Real\"\xae\x01\n\x0eMethodInstance\x12\n\n\x02id\x18\x01 \x01(\t\x12\x13\n\x0bmethod_name\x18\x02 \x01(\t\x12\x19\n\nparameters\x18\x03 \x03(\x0b\x32\x05.Atom\x12/\n\x08subtasks\x18\x06 \x03(\x0b\x32\x1d.MethodInstance.SubtasksEntry\x1a/\n\rSubtasksEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x96\x01\n\rPlanHierarchy\x12\x31\n\nroot_tasks\x18\x01 \x03(\x0b\x32\x1d.PlanHierarchy.RootTasksEntry\x12 \n\x07methods\x18\x02 \x03(\x0b\x32\x0f.MethodInstance\x1a\x30\n\x0eRootTasksEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"h\n\x04Plan\x12 \n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x0f.ActionInstance\x12!\n\thierarchy\x18\x02 \x01(\x0b\x32\x0e.PlanHierarchy\x12\x1b\n\x08schedule\x18\x03 \x01(\x0b\x32\t.Schedule\"\x83\x02\n\x0bPlanRequest\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12*\n\x0fresolution_mode\x18\x02 \x01(\x0e\x32\x11.PlanRequest.Mode\x12\x0f\n\x07timeout\x18\x03 \x01(\x01\x12\x37\n\x0e\x65ngine_options\x18\x04 \x03(\x0b\x32\x1f.PlanRequest.EngineOptionsEntry\x1a\x34\n\x12\x45ngineOptionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"-\n\x04Mode\x12\x0f\n\x0bSATISFIABLE\x10\x00\x12\x14\n\x10SOLVED_OPTIMALLY\x10\x01\"C\n\x11ValidationRequest\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12\x13\n\x04plan\x18\x02 \x01(\x0b\x32\x05.Plan\"{\n\nLogMessage\x12#\n\x05level\x18\x01 \x01(\x0e\x32\x14.LogMessage.LogLevel\x12\x0f\n\x07message\x18\x02 \x01(\t\"7\n\x08LogLevel\x12\t\n\x05\x44\x45\x42UG\x10\x00\x12\x08\n\x04INFO\x10\x01\x12\x0b\n\x07WARNING\x10\x02\x12\t\n\x05\x45RROR\x10\x03\"\xbf\x03\n\x14PlanGenerationResult\x12,\n\x06status\x18\x01 \x01(\x0e\x32\x1c.PlanGenerationResult.Status\x12\x13\n\x04plan\x18\x02 \x01(\x0b\x32\x05.Plan\x12\x33\n\x07metrics\x18\x03 \x03(\x0b\x32\".PlanGenerationResult.MetricsEntry\x12!\n\x0clog_messages\x18\x04 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x05 \x01(\x0b\x32\x07.Engine\x1a.\n\x0cMetricsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xc2\x01\n\x06Status\x12\x16\n\x12SOLVED_SATISFICING\x10\x00\x12\x14\n\x10SOLVED_OPTIMALLY\x10\x01\x12\x15\n\x11UNSOLVABLE_PROVEN\x10\x02\x12\x1b\n\x17UNSOLVABLE_INCOMPLETELY\x10\x03\x12\x0b\n\x07TIMEOUT\x10\r\x12\n\n\x06MEMOUT\x10\x0e\x12\x12\n\x0eINTERNAL_ERROR\x10\x0f\x12\x17\n\x13UNSUPPORTED_PROBLEM\x10\x10\x12\x10\n\x0cINTERMEDIATE\x10\x11\"\x16\n\x06\x45ngine\x12\x0c\n\x04name\x18\x01 \x01(\t\"\xa8\x02\n\x10ValidationResult\x12\x38\n\x06status\x18\x01 \x01(\x0e\x32(.ValidationResult.ValidationResultStatus\x12/\n\x07metrics\x18\x04 \x03(\x0b\x32\x1e.ValidationResult.MetricsEntry\x12!\n\x0clog_messages\x18\x02 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x03 \x01(\x0b\x32\x07.Engine\x1a.\n\x0cMetricsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"=\n\x16ValidationResultStatus\x12\t\n\x05VALID\x10\x00\x12\x0b\n\x07INVALID\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\"\xc4\x02\n\x0e\x43ompilerResult\x12\x19\n\x07problem\x18\x01 \x01(\x0b\x32\x08.Problem\x12\x37\n\rmap_back_plan\x18\x02 \x03(\x0b\x32 .CompilerResult.MapBackPlanEntry\x12-\n\x07metrics\x18\x05 \x03(\x0b\x32\x1c.CompilerResult.MetricsEntry\x12!\n\x0clog_messages\x18\x03 \x03(\x0b\x32\x0b.LogMessage\x12\x17\n\x06\x65ngine\x18\x04 \x01(\x0b\x32\x07.Engine\x1a\x43\n\x10MapBackPlanEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1e\n\x05value\x18\x02 \x01(\x0b\x32\x0f.ActionInstance:\x02\x38\x01\x1a.\n\x0cMetricsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01*\xb0\x01\n\x0e\x45xpressionKind\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0c\n\x08\x43ONSTANT\x10\x01\x12\r\n\tPARAMETER\x10\x02\x12\x0c\n\x08VARIABLE\x10\x07\x12\x11\n\rFLUENT_SYMBOL\x10\x03\x12\x13\n\x0f\x46UNCTION_SYMBOL\x10\x04\x12\x12\n\x0eSTATE_VARIABLE\x10\x05\x12\x18\n\x14\x46UNCTION_APPLICATION\x10\x06\x12\x10\n\x0c\x43ONTAINER_ID\x10\x08*\x96\x0e\n\x07\x46\x65\x61ture\x12\x10\n\x0c\x41\x43TION_BASED\x10\x00\x12\x10\n\x0cHIERARCHICAL\x10\x1a\x12\x0e\n\nSCHEDULING\x10\x38\x12\x1b\n\x17SIMPLE_NUMERIC_PLANNING\x10\x1e\x12\x1c\n\x18GENERAL_NUMERIC_PLANNING\x10\x1f\x12\x13\n\x0f\x43ONTINUOUS_TIME\x10\x01\x12\x11\n\rDISCRETE_TIME\x10\x02\x12\'\n#INTERMEDIATE_CONDITIONS_AND_EFFECTS\x10\x03\x12#\n\x1f\x45XTERNAL_CONDITIONS_AND_EFFECTS\x10\'\x12\x11\n\rTIMED_EFFECTS\x10\x04\x12\x0f\n\x0bTIMED_GOALS\x10\x05\x12\x19\n\x15\x44URATION_INEQUALITIES\x10\x06\x12\x14\n\x10SELF_OVERLAPPING\x10/\x12\x1f\n\x1bSTATIC_FLUENTS_IN_DURATIONS\x10\x1b\x12\x18\n\x14\x46LUENTS_IN_DURATIONS\x10\x1c\x12\x17\n\x13REAL_TYPE_DURATIONS\x10>\x12\x16\n\x12INT_TYPE_DURATIONS\x10?\x12\x16\n\x12\x43ONTINUOUS_NUMBERS\x10\x07\x12\x14\n\x10\x44ISCRETE_NUMBERS\x10\x08\x12\x11\n\rBOUNDED_TYPES\x10&\x12\x17\n\x13NEGATIVE_CONDITIONS\x10\t\x12\x1a\n\x16\x44ISJUNCTIVE_CONDITIONS\x10\n\x12\x0e\n\nEQUALITIES\x10\x0b\x12\x1a\n\x16\x45XISTENTIAL_CONDITIONS\x10\x0c\x12\x18\n\x14UNIVERSAL_CONDITIONS\x10\r\x12\x17\n\x13\x43ONDITIONAL_EFFECTS\x10\x0e\x12\x14\n\x10INCREASE_EFFECTS\x10\x0f\x12\x14\n\x10\x44\x45\x43REASE_EFFECTS\x10\x10\x12)\n%STATIC_FLUENTS_IN_BOOLEAN_ASSIGNMENTS\x10)\x12)\n%STATIC_FLUENTS_IN_NUMERIC_ASSIGNMENTS\x10*\x12(\n$STATIC_FLUENTS_IN_OBJECT_ASSIGNMENTS\x10\x39\x12\"\n\x1e\x46LUENTS_IN_BOOLEAN_ASSIGNMENTS\x10+\x12\"\n\x1e\x46LUENTS_IN_NUMERIC_ASSIGNMENTS\x10,\x12!\n\x1d\x46LUENTS_IN_OBJECT_ASSIGNMENTS\x10:\x12\x12\n\x0e\x46ORALL_EFFECTS\x10;\x12\x0f\n\x0b\x46LAT_TYPING\x10\x11\x12\x17\n\x13HIERARCHICAL_TYPING\x10\x12\x12\x13\n\x0fNUMERIC_FLUENTS\x10\x13\x12\x12\n\x0eOBJECT_FLUENTS\x10\x14\x12\x0f\n\x0bINT_FLUENTS\x10<\x12\x10\n\x0cREAL_FLUENTS\x10=\x12\x1a\n\x16\x42OOL_FLUENT_PARAMETERS\x10\x32\x12!\n\x1d\x42OUNDED_INT_FLUENT_PARAMETERS\x10\x33\x12\x1a\n\x16\x42OOL_ACTION_PARAMETERS\x10\x34\x12!\n\x1d\x42OUNDED_INT_ACTION_PARAMETERS\x10\x35\x12#\n\x1fUNBOUNDED_INT_ACTION_PARAMETERS\x10\x36\x12\x1a\n\x16REAL_ACTION_PARAMETERS\x10\x37\x12\x10\n\x0c\x41\x43TIONS_COST\x10\x15\x12\x0f\n\x0b\x46INAL_VALUE\x10\x16\x12\x0c\n\x08MAKESPAN\x10\x17\x12\x0f\n\x0bPLAN_LENGTH\x10\x18\x12\x14\n\x10OVERSUBSCRIPTION\x10\x1d\x12\x1d\n\x19TEMPORAL_OVERSUBSCRIPTION\x10(\x12\"\n\x1eSTATIC_FLUENTS_IN_ACTIONS_COST\x10-\x12\x1b\n\x17\x46LUENTS_IN_ACTIONS_COST\x10.\x12 \n\x1cREAL_NUMBERS_IN_ACTIONS_COST\x10@\x12\x1f\n\x1bINT_NUMBERS_IN_ACTIONS_COST\x10\x41\x12$\n REAL_NUMBERS_IN_OVERSUBSCRIPTION\x10\x42\x12#\n\x1fINT_NUMBERS_IN_OVERSUBSCRIPTION\x10\x43\x12\x15\n\x11SIMULATED_EFFECTS\x10\x19\x12\x1a\n\x16TRAJECTORY_CONSTRAINTS\x10\x30\x12\x14\n\x10STATE_INVARIANTS\x10\x31\x12\x18\n\x14METHOD_PRECONDITIONS\x10 \x12\x1c\n\x18TASK_NETWORK_CONSTRAINTS\x10!\x12\"\n\x1eINITIAL_TASK_NETWORK_VARIABLES\x10\"\x12\x14\n\x10TASK_ORDER_TOTAL\x10#\x12\x16\n\x12TASK_ORDER_PARTIAL\x10$\x12\x17\n\x13TASK_ORDER_TEMPORAL\x10%2\xd8\x01\n\x0fUnifiedPlanning\x12\x34\n\x0bplanAnytime\x12\x0c.PlanRequest\x1a\x15.PlanGenerationResult0\x01\x12\x32\n\x0bplanOneShot\x12\x0c.PlanRequest\x1a\x15.PlanGenerationResult\x12\x35\n\x0cvalidatePlan\x12\x12.ValidationRequest\x1a\x11.ValidationResult\x12$\n\x07\x63ompile\x12\x08.Problem\x1a\x0f.CompilerResultb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'unified_planning_pb2', globals()) @@ -32,12 +32,16 @@ _PLANREQUEST_ENGINEOPTIONSENTRY._serialized_options = b'8\001' _PLANGENERATIONRESULT_METRICSENTRY._options = None _PLANGENERATIONRESULT_METRICSENTRY._serialized_options = b'8\001' + _VALIDATIONRESULT_METRICSENTRY._options = None + _VALIDATIONRESULT_METRICSENTRY._serialized_options = b'8\001' _COMPILERRESULT_MAPBACKPLANENTRY._options = None _COMPILERRESULT_MAPBACKPLANENTRY._serialized_options = b'8\001' - _EXPRESSIONKIND._serialized_start=5974 - _EXPRESSIONKIND._serialized_end=6150 - _FEATURE._serialized_start=6153 - _FEATURE._serialized_end=7967 + _COMPILERRESULT_METRICSENTRY._options = None + _COMPILERRESULT_METRICSENTRY._serialized_options = b'8\001' + _EXPRESSIONKIND._serialized_start=6166 + _EXPRESSIONKIND._serialized_end=6342 + _FEATURE._serialized_start=6345 + _FEATURE._serialized_end=8159 _EXPRESSION._serialized_start=26 _EXPRESSION._serialized_end=131 _ATOM._serialized_start=133 @@ -143,13 +147,17 @@ _ENGINE._serialized_start=5515 _ENGINE._serialized_end=5537 _VALIDATIONRESULT._serialized_start=5540 - _VALIDATIONRESULT._serialized_end=5739 - _VALIDATIONRESULT_VALIDATIONRESULTSTATUS._serialized_start=5678 - _VALIDATIONRESULT_VALIDATIONRESULTSTATUS._serialized_end=5739 - _COMPILERRESULT._serialized_start=5742 - _COMPILERRESULT._serialized_end=5971 - _COMPILERRESULT_MAPBACKPLANENTRY._serialized_start=5904 - _COMPILERRESULT_MAPBACKPLANENTRY._serialized_end=5971 - _UNIFIEDPLANNING._serialized_start=7970 - _UNIFIEDPLANNING._serialized_end=8186 + _VALIDATIONRESULT._serialized_end=5836 + _VALIDATIONRESULT_METRICSENTRY._serialized_start=5270 + _VALIDATIONRESULT_METRICSENTRY._serialized_end=5316 + _VALIDATIONRESULT_VALIDATIONRESULTSTATUS._serialized_start=5775 + _VALIDATIONRESULT_VALIDATIONRESULTSTATUS._serialized_end=5836 + _COMPILERRESULT._serialized_start=5839 + _COMPILERRESULT._serialized_end=6163 + _COMPILERRESULT_MAPBACKPLANENTRY._serialized_start=6048 + _COMPILERRESULT_MAPBACKPLANENTRY._serialized_end=6115 + _COMPILERRESULT_METRICSENTRY._serialized_start=5270 + _COMPILERRESULT_METRICSENTRY._serialized_end=5316 + _UNIFIEDPLANNING._serialized_start=8162 + _UNIFIEDPLANNING._serialized_end=8378 # @@protoc_insertion_point(module_scope) diff --git a/unified_planning/grpc/proto_reader.py b/unified_planning/grpc/proto_reader.py index 1b8658cb7..5fc1beda9 100644 --- a/unified_planning/grpc/proto_reader.py +++ b/unified_planning/grpc/proto_reader.py @@ -848,10 +848,10 @@ def _convert_plan_generation_result( raise UPException(f"Unknown Planner Status: {result.status}") log_messages = None - metrics = None + engine_metrics = None if bool(result.metrics): - metrics = dict(result.metrics) + engine_metrics = dict(result.metrics) if len(result.log_messages) > 0: log_messages = [self.convert(log) for log in result.log_messages] @@ -862,7 +862,7 @@ def _convert_plan_generation_result( if result.HasField("plan") else None, engine_name=result.engine.name, - metrics=metrics, + metrics=engine_metrics, log_messages=log_messages, ) @@ -912,12 +912,16 @@ def _convert_compiler_result( original_action_instance.action, original_action_instance.actual_parameters, ) + engine_metrics = None + if bool(result.metrics): + engine_metrics = dict(result.metrics) return unified_planning.engines.CompilerResult( problem=problem, map_back_action_instance=partial( unified_planning.engines.compilers.utils.lift_action_instance, map=map ), engine_name=result.engine.name, + metrics=engine_metrics, log_messages=[self.convert(log) for log in result.log_messages], ) @@ -939,8 +943,12 @@ def _convert_validation_result( r_status = unified_planning.engines.ValidationResultStatus.UNKNOWN else: raise UPException(f"Unexpected ValidationResult status: {result.status}") + engine_metrics = None + if bool(result.metrics): + engine_metrics = dict(result.metrics) return unified_planning.engines.ValidationResult( status=r_status, engine_name=result.engine.name, + metrics=engine_metrics, log_messages=[self.convert(log) for log in result.log_messages], ) diff --git a/unified_planning/grpc/proto_writer.py b/unified_planning/grpc/proto_writer.py index df64a7a3a..e38280387 100644 --- a/unified_planning/grpc/proto_writer.py +++ b/unified_planning/grpc/proto_writer.py @@ -980,6 +980,7 @@ def _convert_compiler_result( return proto.CompilerResult( problem=self.convert(result.problem), map_back_plan=map, + metrics=result.metrics, log_messages=[self.convert(log) for log in log_messages], engine=proto.Engine(name=result.engine_name), ) @@ -990,6 +991,7 @@ def _convert_validation_result( ) -> proto.ValidationResult: return proto.ValidationResult( status=self.convert(result.status), + metrics=result.metrics, log_messages=[self.convert(log) for log in result.log_messages], engine=proto.Engine(name=result.engine_name), ) diff --git a/unified_planning/grpc/unified_planning.proto b/unified_planning/grpc/unified_planning.proto index 6af410df0..99085ebb2 100644 --- a/unified_planning/grpc/unified_planning.proto +++ b/unified_planning/grpc/unified_planning.proto @@ -844,6 +844,9 @@ message ValidationResult { } ValidationResultStatus status = 1; + // A set of engine specific values that can be reported + map metrics = 4; + // Optional. Information given by the engine to the user. repeated LogMessage log_messages = 2; @@ -861,6 +864,9 @@ message CompilerResult { // compiled problem to the original ActionInstance. map map_back_plan = 2; + // A set of engine specific values that can be reported + map metrics = 5; + // Optional. Information given by the engine to the user. repeated LogMessage log_messages = 3; diff --git a/up_test_cases/report.py b/up_test_cases/report.py index e2d62ff53..a43d486d8 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -261,9 +261,9 @@ def report_oneshot( errors.append((planner_id, name)) total_execution_time = end - start internal_time_str = None - if result.extra_engine_info is not None: - internal_time_str = result.extra_engine_info.get( - "internal_time", None + if result.metrics is not None: + internal_time_str = result.metrics.get( + "engine_internal_time", None ) if internal_time_str is not None: internal_time = float(internal_time_str) @@ -395,9 +395,9 @@ def report_anytime( ) total_execution_time = end - start internal_time_str = None - if result.extra_engine_info is not None: - internal_time_str = result.extra_engine_info.get( - "internal_time", None + if result.metrics is not None: + internal_time_str = result.metrics.get( + "engine_internal_time", None ) if internal_time_str is not None: internal_time = float(internal_time_str) From ffc5a3917a7f2ea6302ef4ba6e49d9dc267798f0 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Wed, 8 Nov 2023 16:56:34 +0100 Subject: [PATCH 05/17] Added plan repair in report.py --- up_test_cases/report.py | 180 ++++++++++++++++++++++++++++------------ up_test_cases/utils.py | 4 +- 2 files changed, 128 insertions(+), 56 deletions(-) diff --git a/up_test_cases/report.py b/up_test_cases/report.py index a43d486d8..a444e40fe 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -18,6 +18,7 @@ AnytimePlannerMixin, PlanValidatorMixin, OneshotPlannerMixin, + PlanRepairerMixin, ) from unified_planning.plans import Plan @@ -62,6 +63,32 @@ def get_test_cases_from_packages(packages: List[str]) -> Dict[str, TestCase]: return res +def report_runtime( + metrics: Optional[Dict[str, str]], total_time: float, max_overhead: float +) -> str: + internal_time_str = None + if metrics is not None: + internal_time_str = metrics.get("engine_internal_time", None) + if internal_time_str is not None: + internal_time = float(internal_time_str) + overhead_percentage = (total_time - internal_time) / internal_time + else: + overhead_percentage = None + if total_time > 1 and overhead_percentage is not None: + overhead_str = "{:.0%}".format(overhead_percentage) + overhead = ( + Ok(overhead_str) + if overhead_percentage < max_overhead + else Err(overhead_str) + ) + runtime_report = "{:.3f}s {}".format(total_time, overhead).ljust(30) + elif total_time < 1: + runtime_report = "{:.3f}s {}".format(total_time, Ok("<1s")).ljust(30) + else: + runtime_report = "{:.3f}s".format(total_time).ljust(21) + return runtime_report + + def validate_plan( plan: Plan, problem: AbstractProblem ) -> Tuple[ResultSet, Optional[Dict[PlanQualityMetric, Union[int, Fraction]]]]: @@ -227,13 +254,13 @@ def report_oneshot( print(name.ljust(40), end="\n") print("| ", planner_id.ljust(40), end="") - start = time.time() try: assert isinstance( planner, OneshotPlannerMixin ), "Error in oneshot planners selection" + start = time.time() result = planner.solve(pb, timeout=timeout) - end = time.time() + total_execution_time = time.time() - start status = str(result.status.name).ljust(25) outcome, metrics_evaluation = check_result( test_case, result, planner @@ -259,25 +286,9 @@ def report_oneshot( ) if not outcome.ok(): errors.append((planner_id, name)) - total_execution_time = end - start - internal_time_str = None - if result.metrics is not None: - internal_time_str = result.metrics.get( - "engine_internal_time", None - ) - if internal_time_str is not None: - internal_time = float(internal_time_str) - # overhead_percentage = 1-internal_time/total_execution_time - overhead_percentage = ( - total_execution_time - internal_time - ) / internal_time - runtime_report = "{:.3f}s({:.3%})".format( - total_execution_time, overhead_percentage - ).ljust(15) - else: - runtime_report = "{:.3f}s".format(total_execution_time).ljust( - 15 - ) + runtime_report = report_runtime( + result.metrics, total_execution_time, 0.10 + ) print(status, " ", runtime_report, outcome) except Exception as e: @@ -295,6 +306,67 @@ def report_oneshot( return errors +def report_plan_repair( + engines: List[str], problems: Dict[str, TestCase] +) -> List[Tuple[str, str]]: + """Run all plan repairer on all the given problems""" + + factory = get_environment().factory + # filter PlanRepairer + planners = list(filter(lambda name: factory.engine(name).is_plan_repairer(), engines)) # type: ignore [attr-defined, arg-type] + + print("\n\nPLAN REPAIR:") + errors = [] + problems_skipped = [] + problems_run = 0 + for name, test_case in problems.items(): + pb = test_case.problem + for i, plan in enumerate(test_case.invalid_plans): + name_printed = False + for planner_id in planners: + planner = PlanRepairer(name=planner_id) + if planner.supports(pb.kind) and planner.supports_plan(plan.kind): + + if not name_printed: + problems_run += 1 + name_printed = True + print() + print(f"{name} [{i}]".ljust(40), end="\n") + + print("| ", planner_id.ljust(40), end="") + try: + assert isinstance( + planner, PlanRepairerMixin + ), "Error in plan repairer selection" + start = time.time() + result = planner.repair(pb, plan) + total_execution_time = time.time() - start + status = str(result.status.name).ljust(25) + outcome, metrics_evaluation = check_result( + test_case, result, planner + ) + if not outcome.ok(): + errors.append((planner_id, f"{name} [{i}]")) + runtime_report = report_runtime( + result.metrics, total_execution_time, 0.10 + ) + print(status, " ", runtime_report, outcome) + + except Exception as e: + print(f"{bcolors.ERR}CRASH{bcolors.ENDC}", e) + errors.append((planner_id, f"{name} [{i}]")) + if not name_printed: + problems_skipped.append(f"{name} [{i}]") + + if problems_run == 0: + print("\n\nPlan Repair problems skipped: ALL") + elif problems_skipped: + print("\n\nPlan Repair problems skipped:") + print(" ", "\n ".join(problems_skipped)) + + return errors + + def check_anytime_solution_improvement( problem: AbstractProblem, metrics_evaluations: List[Dict[PlanQualityMetric, Union[int, Fraction]]], @@ -361,7 +433,6 @@ def report_anytime( print(name.ljust(40), end="\n") print("| ", planner_id.ljust(40), end="") - start = time.time() try: outcome = Void() metrics_evaluations: List[ @@ -370,6 +441,7 @@ def report_anytime( assert isinstance( planner, AnytimePlannerMixin ), "Error in Anytime selection" + start = time.time() for result in planner.get_solutions(pb, timeout=timeout): status = str(result.status.name).ljust(25) validity, metrics_evaluation = check_result( @@ -380,7 +452,7 @@ def report_anytime( metrics_evaluations.append(metrics_evaluation) if not outcome.ok(): errors.append((planner_id, name)) - end = time.time() + total_execution_time = time.time() - start if test_case.solvable and planner.ensures( AnytimeGuarantee.INCREASING_QUALITY ): @@ -393,25 +465,9 @@ def report_anytime( outcome += check_all_optimal_solutions( test_case, metrics_evaluations ) - total_execution_time = end - start - internal_time_str = None - if result.metrics is not None: - internal_time_str = result.metrics.get( - "engine_internal_time", None - ) - if internal_time_str is not None: - internal_time = float(internal_time_str) - # overhead_percentage = 1-internal_time/total_execution_time - overhead_percentage = ( - total_execution_time - internal_time - ) / internal_time - runtime_report = "{:.3f}s({:.0%})".format( - total_execution_time, overhead_percentage - ).ljust(15) - else: - runtime_report = "{:.3f}s".format(total_execution_time).ljust( - 15 - ) + runtime_report = report_runtime( + result.metrics, total_execution_time, 0.15 + ) print(status, " ", runtime_report, outcome) except Exception as e: @@ -462,10 +518,12 @@ def applicable_validators(pb, plan): print("| ", validator.name.ljust(40), end="") start = time.time() result = validator.validate(test_case.problem, valid_plan) - end = time.time() + total_execution_time = time.time() - start print(str(result.status.name).ljust(25), end=" ") - runtime = "{:.3f}s".format(end - start).ljust(15) - print(runtime, end="") + runtime_report = report_runtime( + result.metrics, total_execution_time, 0.05 + ) + print(runtime_report, end="") if result.status == ValidationResultStatus.VALID: print(Ok("Valid")) else: @@ -485,10 +543,12 @@ def applicable_validators(pb, plan): print("| ", validator.name.ljust(40), end="") start = time.time() result = validator.validate(test_case.problem, invalid_plan) - end = time.time() + total_execution_time = time.time() - start print(str(result.status.name).ljust(25), end=" ") - runtime = "{:.3f}s".format(end - start).ljust(15) - print(runtime, end="") + runtime_report = report_runtime( + result.metrics, total_execution_time, 0.05 + ) + print(runtime_report, end="") if result.status == ValidationResultStatus.INVALID: print(Ok("Invalid")) else: @@ -572,11 +632,9 @@ def is_grounder(engine_name): return errors -def main(args=None): - if args is None: - args = sys.argv[1:] +def main(): parser = get_report_parser() - parsed_args = parser.parse_args(args) + parsed_args = parser.parse_args() engines = parsed_args.engines if not engines: engines = get_environment().factory.engines @@ -617,6 +675,8 @@ def main(args=None): oneshot_errors = report_oneshot(engines, problem_test_cases, timeout) if "anytime" in modes: anytime_errors = report_anytime(engines, problem_test_cases, timeout) + if "repair" in modes: + repair_errors = report_plan_repair(engines, problem_test_cases) if "validation" in modes: validation_errors = report_validation(engines, problem_test_cases) if "grounding" in modes: @@ -631,6 +691,12 @@ def main(args=None): print( "Anytime errors:\n ", "\n ".join(map(str, anytime_errors)), end="\n\n" ) + if repair_errors: + print( + "Plan Repair errors:\n ", + "\n ".join(map(str, repair_errors)), + end="\n\n", + ) if validation_errors: print( "Validation errors:\n ", @@ -644,7 +710,13 @@ def main(args=None): end="\n\n", ) errors = list( - chain(oneshot_errors, validation_errors, anytime_errors, grounding_errors) + chain( + oneshot_errors, + validation_errors, + anytime_errors, + repair_errors, + grounding_errors, + ) ) if len(errors) > 0: @@ -652,4 +724,4 @@ def main(args=None): if __name__ == "__main__": - main(sys.argv[1:]) + main() diff --git a/up_test_cases/utils.py b/up_test_cases/utils.py index 02afd0450..f1e12c8eb 100644 --- a/up_test_cases/utils.py +++ b/up_test_cases/utils.py @@ -222,10 +222,10 @@ def get_report_parser() -> argparse.ArgumentParser: "--modes", type=str, nargs="+", - choices=["oneshot", "anytime", "validation", "grounding"], + choices=["oneshot", "anytime", "validation", "grounding", "repair"], help="Performs only the specified modes; if not specified tests all the modes.", dest="modes", - default=["oneshot", "anytime", "validation", "grounding"], + default=["oneshot", "anytime", "validation", "grounding", "repair"], ) parser.add_argument( From 67a070184851f4a2c6553a085c0d010a644d111c Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Thu, 9 Nov 2023 13:57:27 +0100 Subject: [PATCH 06/17] Minor fix in report.py --- up_test_cases/report.py | 1 + 1 file changed, 1 insertion(+) diff --git a/up_test_cases/report.py b/up_test_cases/report.py index a444e40fe..5c3692ffa 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -667,6 +667,7 @@ def main(): validation_errors = [] anytime_errors = [] grounding_errors = [] + repair_errors = [] with warnings.catch_warnings(): warnings.simplefilter("ignore") From fa6048d06889f07c98010110512965836435b840 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Thu, 9 Nov 2023 15:22:17 +0100 Subject: [PATCH 07/17] Added plan repair test cases --- .../builtin/classical/depots/__init__.py | 9 +++ .../depots/pddl_files/depots_domain.pddl | 39 +++++++++++ .../depots/pddl_files/depots_p01.pddl | 47 +++++++++++++ .../depots/pddl_files/depots_p01_invalid.plan | 5 ++ .../depots/pddl_files/depots_p02.pddl | 57 +++++++++++++++ .../depots/pddl_files/depots_p02_invalid.plan | 9 +++ .../depots/pddl_files/depots_p03.pddl | 67 ++++++++++++++++++ .../depots/pddl_files/depots_p03_invalid.plan | 9 +++ .../builtin/classical/tpp/__init__.py | 11 +++ .../classical/tpp/pddl_files/tpp_domain.pddl | 65 +++++++++++++++++ .../classical/tpp/pddl_files/tpp_p01.pddl | 23 ++++++ .../tpp/pddl_files/tpp_p01_invalid.plan | 3 + .../classical/tpp/pddl_files/tpp_p02.pddl | 28 ++++++++ .../tpp/pddl_files/tpp_p02_invalid.plan | 5 ++ .../classical/tpp/pddl_files/tpp_p03.pddl | 33 +++++++++ .../tpp/pddl_files/tpp_p03_invalid.plan | 7 ++ .../classical/tpp/pddl_files/tpp_p06.pddl | 70 +++++++++++++++++++ .../tpp/pddl_files/tpp_p06_invalid.plan | 17 +++++ .../pddl_files/depots_pfile10_invalid.plan | 13 ++++ .../pddl_files/depots_pfile11_invalid.plan | 53 ++++++++++++++ .../pddl_files/depots_pfile1_invalid.plan | 5 ++ .../pddl_files/depots_pfile2_invalid.plan | 11 +++ .../pddl_files/depots_pfile3_invalid.plan | 40 +++++++++++ .../pddl_files/farmland_10_1000_1229.pddl | 0 .../pddl_files/farmland_10_400_1229.pddl | 0 .../pddl_files/farmland_2_100_1229.pddl | 0 .../pddl_files/farmland_2_200_1229.pddl | 0 .../pddl_files/farmland_2_300_1229.pddl | 0 .../pddl_files/farmland_8_400_1229.pddl | 0 .../farmlands/pddl_files/farmland_domain.pddl | 0 .../fn_counters/pddl_files/fn_counters_2.pddl | 0 .../pddl_files/fn_counters_2_invalid.plan | 1 + .../fn_counters/pddl_files/fn_counters_4.pddl | 0 .../pddl_files/fn_counters_4_invalid.plan | 8 +++ .../fn_counters/pddl_files/fn_counters_8.pddl | 0 .../pddl_files/fn_counters_8_invalid.plan | 40 +++++++++++ .../pddl_files/fn_counters_domain.pddl | 0 .../pddl_files/plant_watering_4_1.pddl | 0 .../pddl_files/plant_watering_4_2.pddl | 0 .../pddl_files/plant_watering_4_3.pddl | 0 .../pddl_files/plant_watering_domain.pddl | 0 .../pddl_files/rovers_pfile2_invalid.plan | 8 +++ .../pddl_files/rovers_pfile3_invalid.plan | 7 ++ .../pddl_files/rovers_pfile4_invalid.plan | 4 ++ .../pddl_files/rovers_pfile5_invalid.plan | 11 +++ .../sailing/pddl_files/sailing_1_1_1229.pddl | 0 .../sailing/pddl_files/sailing_1_2_1229.pddl | 0 .../sailing/pddl_files/sailing_1_3_1229.pddl | 0 .../sailing/pddl_files/sailing_3_3_1229.pddl | 0 .../sailing/pddl_files/sailing_4_10_1229.pddl | 0 .../sailing/pddl_files/sailing_domain.pddl | 0 .../pddl_files/depots_pfile10_invalid.plan | 9 +++ .../pddl_files/depots_pfile11_invalid.plan | 15 ++++ .../pddl_files/depots_pfile1_invalid.plan | 2 + .../pddl_files/depots_pfile2_invalid.plan | 6 ++ .../pddl_files/depots_pfile3_invalid.plan | 12 ++++ up_test_cases/utils.py | 20 +++++- 57 files changed, 767 insertions(+), 2 deletions(-) create mode 100644 up_test_cases/builtin/classical/depots/__init__.py create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_domain.pddl create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p01.pddl create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p01_invalid.plan create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p02.pddl create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p02_invalid.plan create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p03.pddl create mode 100644 up_test_cases/builtin/classical/depots/pddl_files/depots_p03_invalid.plan create mode 100644 up_test_cases/builtin/classical/tpp/__init__.py create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_domain.pddl create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01.pddl create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01_invalid.plan create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02.pddl create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02_invalid.plan create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03.pddl create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03_invalid.plan create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06.pddl create mode 100644 up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06_invalid.plan create mode 100644 up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile10_invalid.plan create mode 100644 up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile11_invalid.plan create mode 100644 up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile1_invalid.plan create mode 100644 up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile2_invalid.plan create mode 100644 up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile3_invalid.plan mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_100_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_200_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_300_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_8_400_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_domain.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2.pddl create mode 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2_invalid.plan mode change 100755 => 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4.pddl create mode 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4_invalid.plan mode change 100755 => 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8.pddl create mode 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan mode change 100755 => 100644 up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_domain.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_1.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_2.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_domain.pddl create mode 100644 up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile2_invalid.plan create mode 100644 up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile3_invalid.plan create mode 100644 up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile4_invalid.plan create mode 100644 up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_1_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_2_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_3_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_3_3_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_4_10_1229.pddl mode change 100755 => 100644 up_test_cases/builtin/numeric/sailing/pddl_files/sailing_domain.pddl create mode 100644 up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile10_invalid.plan create mode 100644 up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile11_invalid.plan create mode 100644 up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1_invalid.plan create mode 100644 up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile2_invalid.plan create mode 100644 up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile3_invalid.plan diff --git a/up_test_cases/builtin/classical/depots/__init__.py b/up_test_cases/builtin/classical/depots/__init__.py new file mode 100644 index 000000000..a2b1739f9 --- /dev/null +++ b/up_test_cases/builtin/classical/depots/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1", "2", "3")) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_domain.pddl b/up_test_cases/builtin/classical/depots/pddl_files/depots_domain.pddl new file mode 100644 index 000000000..5858a4e15 --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_domain.pddl @@ -0,0 +1,39 @@ +(define (domain depot) +(:predicates + (at ?x ?y) (on ?x ?y) (in ?x ?y) (lifting ?x ?y) (available ?x) (clear ?x)(place ?x) (locatable ?x) (depot ?x) (distributor ?x) (truck ?x) (hoist ?x) (surface ?x) (pallet ?x) (crate ?x) ) +(:action drive + :parameters ( ?x ?y ?z) + :precondition + (and (truck ?x) (place ?y) (place ?z) (at ?x ?y)) + :effect + (and (at ?x ?z) (not (at ?x ?y)))) + +(:action lift + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (surface ?z) (place ?p) (at ?x ?p) (available ?x) (at ?y ?p) (on ?y ?z) (clear ?y)) + :effect + (and (lifting ?x ?y) (clear ?z) (not (at ?y ?p)) (not (clear ?y)) (not (available ?x)) (not (on ?y ?z)))) + +(:action drop + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (surface ?z) (place ?p) (at ?x ?p) (at ?z ?p) (clear ?z) (lifting ?x ?y)) + :effect + (and (available ?x) (at ?y ?p) (clear ?y) (on ?y ?z) (not (lifting ?x ?y)) (not (clear ?z)))) + +(:action load + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (truck ?z) (place ?p) (at ?x ?p) (at ?z ?p) (lifting ?x ?y)) + :effect + (and (in ?y ?z) (available ?x) (not (lifting ?x ?y)))) + +(:action unload + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (truck ?z) (place ?p) (at ?x ?p) (at ?z ?p) (available ?x) (in ?y ?z)) + :effect + (and (lifting ?x ?y) (not (in ?y ?z)) (not (available ?x)))) + +) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p01.pddl b/up_test_cases/builtin/classical/depots/pddl_files/depots_p01.pddl new file mode 100644 index 000000000..2e7f48b1b --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p01.pddl @@ -0,0 +1,47 @@ +(define (problem depotprob1818) (:domain Depot) +(:objects + depot0 distributor0 distributor1 truck0 truck1 pallet0 pallet1 pallet2 crate0 crate1 hoist0 hoist1 hoist2 ) +(:init + (pallet pallet0) + (surface pallet0) + (at pallet0 depot0) + (clear crate1) + (pallet pallet1) + (surface pallet1) + (at pallet1 distributor0) + (clear crate0) + (pallet pallet2) + (surface pallet2) + (at pallet2 distributor1) + (clear pallet2) + (truck truck0) + (at truck0 distributor1) + (truck truck1) + (at truck1 depot0) + (hoist hoist0) + (at hoist0 depot0) + (available hoist0) + (hoist hoist1) + (at hoist1 distributor0) + (available hoist1) + (hoist hoist2) + (at hoist2 distributor1) + (available hoist2) + (crate crate0) + (surface crate0) + (at crate0 distributor0) + (on crate0 pallet1) + (crate crate1) + (surface crate1) + (at crate1 depot0) + (on crate1 pallet0) + (place depot0) + (place distributor0) + (place distributor1) +) + +(:goal (and + (on crate0 pallet2) + (on crate1 pallet1) + ) +)) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p01_invalid.plan b/up_test_cases/builtin/classical/depots/pddl_files/depots_p01_invalid.plan new file mode 100644 index 000000000..b703de3cf --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p01_invalid.plan @@ -0,0 +1,5 @@ +(lift hoist1 crate0 pallet1 distributor0) +(load hoist0 crate1 truck1 depot0) +(drive truck1 depot0 distributor1) +(unload hoist2 crate0 truck0 distributor1) +(unload hoist1 crate1 truck1 distributor0) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p02.pddl b/up_test_cases/builtin/classical/depots/pddl_files/depots_p02.pddl new file mode 100644 index 000000000..421de536f --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p02.pddl @@ -0,0 +1,57 @@ +(define (problem depotprob7512) (:domain Depot) +(:objects + depot0 distributor0 distributor1 truck0 truck1 pallet0 pallet1 pallet2 crate0 crate1 crate2 crate3 hoist0 hoist1 hoist2 ) +(:init + (pallet pallet0) + (surface pallet0) + (at pallet0 depot0) + (clear crate0) + (pallet pallet1) + (surface pallet1) + (at pallet1 distributor0) + (clear crate3) + (pallet pallet2) + (surface pallet2) + (at pallet2 distributor1) + (clear crate2) + (truck truck0) + (at truck0 depot0) + (truck truck1) + (at truck1 depot0) + (hoist hoist0) + (at hoist0 depot0) + (available hoist0) + (hoist hoist1) + (at hoist1 distributor0) + (available hoist1) + (hoist hoist2) + (at hoist2 distributor1) + (available hoist2) + (crate crate0) + (surface crate0) + (at crate0 depot0) + (on crate0 pallet0) + (crate crate1) + (surface crate1) + (at crate1 distributor1) + (on crate1 pallet2) + (crate crate2) + (surface crate2) + (at crate2 distributor1) + (on crate2 crate1) + (crate crate3) + (surface crate3) + (at crate3 distributor0) + (on crate3 pallet1) + (place depot0) + (place distributor0) + (place distributor1) +) + +(:goal (and + (on crate0 pallet2) + (on crate1 crate3) + (on crate2 pallet0) + (on crate3 pallet1) + ) +)) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p02_invalid.plan b/up_test_cases/builtin/classical/depots/pddl_files/depots_p02_invalid.plan new file mode 100644 index 000000000..1dc6fbc57 --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p02_invalid.plan @@ -0,0 +1,9 @@ +(lift hoist0 crate0 pallet0 depot0) +(load hoist2 crate2 truck1 distributor1) +(load hoist0 crate0 truck1 depot0) +(unload hoist0 crate2 truck1 depot0) +(drop hoist0 crate2 pallet0 depot0) +(load hoist2 crate1 truck1 distributor1) +(unload hoist2 crate0 truck1 distributor1) +(drop hoist2 crate0 pallet2 distributor1) +(unload hoist1 crate1 truck1 distributor0) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p03.pddl b/up_test_cases/builtin/classical/depots/pddl_files/depots_p03.pddl new file mode 100644 index 000000000..925005b9e --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p03.pddl @@ -0,0 +1,67 @@ +(define (problem depotprob1935) (:domain Depot) +(:objects + depot0 distributor0 distributor1 truck0 truck1 pallet0 pallet1 pallet2 crate0 crate1 crate2 crate3 crate4 crate5 hoist0 hoist1 hoist2 ) +(:init + (pallet pallet0) + (surface pallet0) + (at pallet0 depot0) + (clear crate1) + (pallet pallet1) + (surface pallet1) + (at pallet1 distributor0) + (clear crate4) + (pallet pallet2) + (surface pallet2) + (at pallet2 distributor1) + (clear crate5) + (truck truck0) + (at truck0 depot0) + (truck truck1) + (at truck1 distributor0) + (hoist hoist0) + (at hoist0 depot0) + (available hoist0) + (hoist hoist1) + (at hoist1 distributor0) + (available hoist1) + (hoist hoist2) + (at hoist2 distributor1) + (available hoist2) + (crate crate0) + (surface crate0) + (at crate0 distributor0) + (on crate0 pallet1) + (crate crate1) + (surface crate1) + (at crate1 depot0) + (on crate1 pallet0) + (crate crate2) + (surface crate2) + (at crate2 distributor1) + (on crate2 pallet2) + (crate crate3) + (surface crate3) + (at crate3 distributor0) + (on crate3 crate0) + (crate crate4) + (surface crate4) + (at crate4 distributor0) + (on crate4 crate3) + (crate crate5) + (surface crate5) + (at crate5 distributor1) + (on crate5 crate2) + (place depot0) + (place distributor0) + (place distributor1) +) + +(:goal (and + (on crate0 crate1) + (on crate1 pallet2) + (on crate2 pallet0) + (on crate3 crate2) + (on crate4 pallet1) + (on crate5 crate0) + ) +)) diff --git a/up_test_cases/builtin/classical/depots/pddl_files/depots_p03_invalid.plan b/up_test_cases/builtin/classical/depots/pddl_files/depots_p03_invalid.plan new file mode 100644 index 000000000..1dc6fbc57 --- /dev/null +++ b/up_test_cases/builtin/classical/depots/pddl_files/depots_p03_invalid.plan @@ -0,0 +1,9 @@ +(lift hoist0 crate0 pallet0 depot0) +(load hoist2 crate2 truck1 distributor1) +(load hoist0 crate0 truck1 depot0) +(unload hoist0 crate2 truck1 depot0) +(drop hoist0 crate2 pallet0 depot0) +(load hoist2 crate1 truck1 distributor1) +(unload hoist2 crate0 truck1 distributor1) +(drop hoist2 crate0 pallet2 distributor1) +(unload hoist1 crate1 truck1 distributor0) diff --git a/up_test_cases/builtin/classical/tpp/__init__.py b/up_test_cases/builtin/classical/tpp/__init__.py new file mode 100644 index 000000000..e0cc3d0ea --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/__init__.py @@ -0,0 +1,11 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +# problems_filenames = ["1", "2", "3", "6",] # TODO choose which to keep + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1", "2", "3")) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_domain.pddl b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_domain.pddl new file mode 100644 index 000000000..45d378fc2 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_domain.pddl @@ -0,0 +1,65 @@ +; IPC5 Domain: TPP Propositional +; Authors: Alfonso Gerevini and Alessandro Saetti + +(define (domain TPP-Propositional) +(:requirements :strips :typing) +(:types place locatable level - object + depot market - place + truck goods - locatable) + +(:predicates (loaded ?g - goods ?t - truck ?l - level) + (ready-to-load ?g - goods ?m - market ?l - level) + (stored ?g - goods ?l - level) + (on-sale ?g - goods ?m - market ?l - level) + (next ?l1 ?l2 - level) + (at ?t - truck ?p - place) + (connected ?p1 ?p2 - place)) + +(:action drive + :parameters (?t - truck ?from ?to - place) + :precondition (and (at ?t ?from) (connected ?from ?to)) + :effect (and (not (at ?t ?from)) (at ?t ?to))) + + +; ### LOAD ### +; ?l1 is the level of ?g ready to be loaded at ?m before loading +; ?l2 is the level of ?g ready to be loaded at ?m after loading +; ?l3 is the level of ?g in ?t before loading +; ?l4 is the level of ?g in ?t after loading + +(:action load + :parameters (?g - goods ?t - truck ?m - market ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?m) (loaded ?g ?t ?l3) + (ready-to-load ?g ?m ?l2) (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (loaded ?g ?t ?l4) (not (loaded ?g ?t ?l3)) + (ready-to-load ?g ?m ?l1) (not (ready-to-load ?g ?m ?l2)))) + + +; ### UNLOAD ### +; ?l1 is the level of ?g in ?t before unloading +; ?l2 is the level of ?g in ?t after unloading +; ?l3 is the level of ?g in ?d before unloading +; ?l4 is the level of ?g in ?d after unloading + +(:action unload + :parameters (?g - goods ?t - truck ?d - depot ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?d) (loaded ?g ?t ?l2) + (stored ?g ?l3) (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (loaded ?g ?t ?l1) (not (loaded ?g ?t ?l2)) + (stored ?g ?l4) (not (stored ?g ?l3)))) + + +; ### BUY ### +; ?l1 is the level of ?g on sale at ?m before buying +; ?l2 is the level of ?g on sale at ?m after buying +; ?l3 is the level of ?g ready to be loaded at ?m before buying +; ?l4 is the level of ?g ready to be loaded at ?m after buying + +(:action buy + :parameters (?t - truck ?g - goods ?m - market ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?m) (on-sale ?g ?m ?l2) (ready-to-load ?g ?m ?l3) + (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (on-sale ?g ?m ?l1) (not (on-sale ?g ?m ?l2)) + (ready-to-load ?g ?m ?l4) (not (ready-to-load ?g ?m ?l3)))) + +) \ No newline at end of file diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01.pddl b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01.pddl new file mode 100644 index 000000000..a045d6956 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01.pddl @@ -0,0 +1,23 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 - goods + truck1 - truck + market1 - market + depot1 - depot + level0 level1 - level) + +(:init + (next level1 level0) + (ready-to-load goods1 market1 level0) + (stored goods1 level0) + (loaded goods1 truck1 level0) + (connected depot1 market1) + (connected market1 depot1) + (on-sale goods1 market1 level1) + (at truck1 depot1)) + +(:goal (and + (stored goods1 level1))) + +) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01_invalid.plan b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01_invalid.plan new file mode 100644 index 000000000..b4cc01586 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p01_invalid.plan @@ -0,0 +1,3 @@ +(buy truck1 goods1 market1 level0 level1 level0 level1) +(load goods1 truck1 market1 level0 level1 level0 level1) +(drive truck1 market1 depot1) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02.pddl b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02.pddl new file mode 100644 index 000000000..c520a4a5b --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02.pddl @@ -0,0 +1,28 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 - goods + truck1 - truck + market1 - market + depot1 - depot + level0 level1 - level) + +(:init + (next level1 level0) + (ready-to-load goods1 market1 level0) + (ready-to-load goods2 market1 level0) + (stored goods1 level0) + (stored goods2 level0) + (loaded goods1 truck1 level0) + (loaded goods2 truck1 level0) + (connected depot1 market1) + (connected market1 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level1) + (at truck1 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level1))) + +) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02_invalid.plan b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02_invalid.plan new file mode 100644 index 000000000..a1bc6a197 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p02_invalid.plan @@ -0,0 +1,5 @@ +(buy truck1 goods2 market1 level0 level1 level0 level1) +(load goods1 truck1 market1 level0 level1 level0 level1) +(drive truck1 market1 depot1) +(drive truck1 depot1 market1) +(drive truck1 market1 depot1) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03.pddl b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03.pddl new file mode 100644 index 000000000..2c9f262b3 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03.pddl @@ -0,0 +1,33 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 goods3 - goods + truck1 - truck + market1 - market + depot1 - depot + level0 level1 - level) + +(:init + (next level1 level0) + (ready-to-load goods1 market1 level0) + (ready-to-load goods2 market1 level0) + (ready-to-load goods3 market1 level0) + (stored goods1 level0) + (stored goods2 level0) + (stored goods3 level0) + (loaded goods1 truck1 level0) + (loaded goods2 truck1 level0) + (loaded goods3 truck1 level0) + (connected depot1 market1) + (connected market1 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level1) + (on-sale goods3 market1 level1) + (at truck1 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level1) + (stored goods3 level1))) + +) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03_invalid.plan b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03_invalid.plan new file mode 100644 index 000000000..f5d8dadac --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p03_invalid.plan @@ -0,0 +1,7 @@ +(buy truck1 goods1 market1 level0 level1 level0 level1) +(buy truck1 goods3 market1 level0 level1 level0 level1) +(load goods1 truck1 market1 level0 level1 level0 level1) +(drive truck1 market1 depot1) +(unload goods2 truck1 depot1 level0 level1 level0 level1) +(drive truck1 depot1 market1) +(drive truck1 market1 depot1) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06.pddl b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06.pddl new file mode 100644 index 000000000..d42c08825 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06.pddl @@ -0,0 +1,70 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 goods3 goods4 goods5 goods6 - goods + truck1 truck2 - truck + market1 market2 - market + depot1 - depot + level0 level1 level2 - level) + +(:init + (next level1 level0) + (next level2 level1) + (ready-to-load goods1 market1 level0) + (ready-to-load goods1 market2 level0) + (ready-to-load goods2 market1 level0) + (ready-to-load goods2 market2 level0) + (ready-to-load goods3 market1 level0) + (ready-to-load goods3 market2 level0) + (ready-to-load goods4 market1 level0) + (ready-to-load goods4 market2 level0) + (ready-to-load goods5 market1 level0) + (ready-to-load goods5 market2 level0) + (ready-to-load goods6 market1 level0) + (ready-to-load goods6 market2 level0) + (stored goods1 level0) + (stored goods2 level0) + (stored goods3 level0) + (stored goods4 level0) + (stored goods5 level0) + (stored goods6 level0) + (loaded goods1 truck1 level0) + (loaded goods1 truck2 level0) + (loaded goods2 truck1 level0) + (loaded goods2 truck2 level0) + (loaded goods3 truck1 level0) + (loaded goods3 truck2 level0) + (loaded goods4 truck1 level0) + (loaded goods4 truck2 level0) + (loaded goods5 truck1 level0) + (loaded goods5 truck2 level0) + (loaded goods6 truck1 level0) + (loaded goods6 truck2 level0) + (connected market1 market2) + (connected market2 market1) + (connected depot1 market2) + (connected market2 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level2) + (on-sale goods3 market1 level1) + (on-sale goods4 market1 level2) + (on-sale goods5 market1 level2) + (on-sale goods6 market1 level2) + (on-sale goods1 market2 level0) + (on-sale goods2 market2 level0) + (on-sale goods3 market2 level1) + (on-sale goods4 market2 level0) + (on-sale goods5 market2 level0) + (on-sale goods6 market2 level0) + (at truck1 depot1) + (at truck2 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level2) + (stored goods3 level1) + (stored goods4 level1) + (stored goods5 level1) + (stored goods6 level1))) + +) diff --git a/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06_invalid.plan b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06_invalid.plan new file mode 100644 index 000000000..5c51ca034 --- /dev/null +++ b/up_test_cases/builtin/classical/tpp/pddl_files/tpp_p06_invalid.plan @@ -0,0 +1,17 @@ +(drive truck1 depot1 market2) +(drive truck1 market2 market1) +(buy truck2 goods1 market1 level0 level1 level0 level1) +(buy truck2 goods5 market1 level1 level2 level0 level1) +(load goods1 truck2 market1 level0 level1 level0 level1) +(buy truck2 goods2 market1 level0 level1 level1 level2) +(load goods6 truck2 market1 level0 level1 level0 level1) +(load goods2 truck1 market1 level1 level2 level0 level1) +(drive truck2 market1 market2) +(unload goods2 truck1 depot1 level0 level1 level0 level1) +(unload goods4 truck2 depot1 level0 level1 level0 level1) +(drive truck2 market2 market1) +(drive truck2 market1 market2) +(drive truck2 market2 depot1) +(unload goods3 truck2 depot1 level0 level1 level0 level1) +(drive truck2 market2 depot1) +(unload goods1 truck2 depot1 level0 level1 level0 level1) diff --git a/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile10_invalid.plan b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile10_invalid.plan new file mode 100644 index 000000000..e393da7bf --- /dev/null +++ b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile10_invalid.plan @@ -0,0 +1,13 @@ +(lift hoist5 crate3 crate2 distributor2) +(lift hoist2 crate4 pallet2 depot2) +(lift hoist0 crate1 pallet0 depot0) +(load hoist2 crate4 truck1 depot2) +(drive truck1 depot2 depot1) +(load hoist1 crate4 truck0 depot1) +(drive truck1 depot1 distributor2) +(load hoist5 crate2 truck0 distributor2) +(drop hoist5 crate4 pallet5 distributor2) +(drive truck0 distributor2 distributor0) +(unload hoist5 crate0 truck1 distributor2) +(unload hoist3 crate2 truck0 distributor0) +(drop hoist5 crate0 crate4 distributor2) diff --git a/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile11_invalid.plan b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile11_invalid.plan new file mode 100644 index 000000000..60cdfd104 --- /dev/null +++ b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile11_invalid.plan @@ -0,0 +1,53 @@ +(lift hoist2 crate9 crate5 depot2) +(drive truck1 distributor0 depot2) +(lift hoist1 crate3 crate0 depot1) +(lift hoist5 crate8 crate7 distributor2) +(drop hoist2 crate5 crate4 depot2) +(lift hoist2 crate5 crate4 depot2) +(lift hoist2 crate5 crate4 depot2) +(drop hoist2 crate5 crate4 depot2) +(drop hoist1 crate3 crate0 depot1) +(lift hoist1 crate3 crate0 depot1) +(load hoist1 crate3 truck0 depot1) +(lift hoist1 crate0 pallet1 depot1) +(load hoist1 crate0 truck0 depot1) +(drive truck0 depot1 distributor0) +(drive truck0 distributor0 depot2) +(load hoist2 crate0 truck1 depot2) +(drive truck0 depot2 distributor2) +(load hoist5 crate8 truck1 distributor2) +(lift hoist5 crate7 crate6 distributor2) +(load hoist5 crate7 truck1 distributor2) +(load hoist5 crate6 truck1 distributor2) +(unload hoist5 crate2 truck1 distributor2) +(drop hoist5 crate2 pallet5 distributor2) +(unload hoist5 crate5 truck1 distributor2) +(lift hoist5 crate5 crate2 distributor2) +(load hoist5 crate5 truck1 distributor2) +(unload hoist5 crate9 truck0 distributor2) +(drop hoist5 crate9 crate2 distributor2) +(drive truck0 distributor2 depot0) +(drop hoist0 crate7 crate1 depot0) +(drive truck1 depot0 distributor0) +(unload hoist3 crate8 truck1 distributor0) +(lift hoist0 crate7 crate1 depot0) +(drop hoist3 crate8 pallet3 distributor0) +(drop hoist0 crate7 crate1 depot0) +(drive truck1 distributor0 depot0) +(load hoist0 crate7 truck1 depot0) +(lift hoist0 crate1 pallet0 depot0) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(drive truck0 distributor2 distributor1) +(lift hoist5 crate6 crate5 distributor2) +(drive truck0 distributor2 distributor1) +(unload hoist4 crate7 truck0 distributor1) +(drive truck0 distributor1 depot2) diff --git a/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile1_invalid.plan b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile1_invalid.plan new file mode 100644 index 000000000..a2f4de037 --- /dev/null +++ b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile1_invalid.plan @@ -0,0 +1,5 @@ +(load hoist1 crate0 truck0 distributor0) +(load hoist0 crate1 truck1 depot0) +(drive truck1 depot0 distributor0) +(unload hoist2 crate0 truck0 distributor1) +(drop hoist2 crate0 pallet2 distributor1) diff --git a/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile2_invalid.plan b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile2_invalid.plan new file mode 100644 index 000000000..6f8afd2b1 --- /dev/null +++ b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile2_invalid.plan @@ -0,0 +1,11 @@ +(lift hoist2 crate2 crate1 distributor1) +(drive truck1 depot0 distributor1) +(load hoist0 crate0 truck0 depot0) +(lift hoist2 crate1 pallet2 distributor1) +(load hoist2 crate1 truck1 distributor1) +(unload hoist2 crate0 truck0 distributor1) +(unload hoist2 crate2 truck1 distributor1) +(load hoist2 crate2 truck0 distributor1) +(drive truck1 distributor1 depot0) +(unload hoist1 crate1 truck1 distributor0) +(drop hoist1 crate1 crate3 distributor0) diff --git a/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile3_invalid.plan b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile3_invalid.plan new file mode 100644 index 000000000..8d0c5bf02 --- /dev/null +++ b/up_test_cases/builtin/numeric/depots/pddl_files/depots_pfile3_invalid.plan @@ -0,0 +1,40 @@ +(lift hoist1 crate4 crate3 distributor0) +(lift hoist2 crate5 crate2 distributor1) +(drive truck0 depot0 distributor1) +(load hoist1 crate4 truck1 distributor0) +(load hoist2 crate5 truck0 distributor1) +(lift hoist1 crate3 crate0 distributor0) +(drive truck0 distributor1 depot0) +(drop hoist1 crate3 crate0 distributor0) +(lift hoist1 crate3 crate0 distributor0) +(drop hoist1 crate3 crate0 distributor0) +(drop hoist1 crate3 crate0 distributor0) +(lift hoist1 crate3 crate0 distributor0) +(drop hoist1 crate3 crate0 distributor0) +(lift hoist1 crate3 crate0 distributor0) +(drop hoist1 crate3 crate0 distributor0) +(lift hoist1 crate0 pallet1 distributor0) +(drive truck1 distributor0 distributor1) +(unload hoist2 crate3 truck1 distributor1) +(load hoist2 crate3 truck1 distributor1) +(drive truck1 distributor1 depot0) +(load hoist0 crate1 truck1 depot0) +(unload hoist0 crate2 truck0 depot0) +(drop hoist0 crate2 pallet0 depot0) +(drive truck0 depot0 distributor1) +(unload hoist0 crate1 truck1 depot0) +(drive truck0 distributor1 depot0) +(unload hoist1 crate1 truck1 distributor0) +(drop hoist1 crate1 pallet1 distributor0) +(lift hoist1 crate1 pallet1 distributor0) +(load hoist1 crate1 truck1 distributor0) +(unload hoist1 crate4 truck1 distributor0) +(drop hoist1 crate4 pallet1 distributor0) +(unload hoist1 crate1 truck1 distributor0) +(drop hoist1 crate1 crate4 distributor0) +(unload hoist0 crate1 truck1 depot0) +(load hoist0 crate1 truck0 depot0) +(drive truck1 depot0 distributor1) +(drop hoist2 crate0 crate1 distributor1) +(unload hoist2 crate5 truck1 distributor1) +(drop hoist2 crate5 crate0 distributor1) diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_100_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_100_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_200_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_200_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_300_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_2_300_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_8_400_1229.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_8_400_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_domain.pddl b/up_test_cases/builtin/numeric/farmlands/pddl_files/farmland_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2.pddl b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2_invalid.plan b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2_invalid.plan new file mode 100644 index 000000000..8d0e2f75e --- /dev/null +++ b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_2_invalid.plan @@ -0,0 +1 @@ +(increment c0) diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4.pddl b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4_invalid.plan b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4_invalid.plan new file mode 100644 index 000000000..15fce3fce --- /dev/null +++ b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_4_invalid.plan @@ -0,0 +1,8 @@ +(increment c2) +(increment c3) +(increment c2) +(increment c1) +(decrement c2) +(increment c2) +(increment c2) +(decrement c2) diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8.pddl b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan new file mode 100644 index 000000000..e9b03b204 --- /dev/null +++ b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan @@ -0,0 +1,40 @@ +(increment c6) +(increment c5) +(decrement c3) +(decrement c5) +(decrement c4) +(increment c7) +(increment c2) +(increment c1) +(increment c6) +(increment c7) +(increment c7) +(decrement c6) +(decrement c1) +(decrement c2) +(decrement c6) +(increment c4) +(increment c5) +(increment c3) +(increment c1) +(increment c2) +(decrement c6) +(decrement c4) +(decrement c2) +(increment c6) +(decrement c4) +(increment c3) +(increment c5) +(increment c2) +(decrement c1) +(increment c2) +(increment c4) +(decrement c5) +(increment c6) +(increment c3) +(decrement c4) +(increment c5) +(increment c6) +(decrement c3) +(increment c4) +(decrement c5) diff --git a/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_domain.pddl b/up_test_cases/builtin/numeric/fn_counters/pddl_files/fn_counters_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_1.pddl b/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_1.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_2.pddl b/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_2.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl b/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_domain.pddl b/up_test_cases/builtin/numeric/plant_watering/pddl_files/plant_watering_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile2_invalid.plan b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile2_invalid.plan new file mode 100644 index 000000000..0615d46c0 --- /dev/null +++ b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile2_invalid.plan @@ -0,0 +1,8 @@ +(NAVIGATE ROVER0 WAYPOINT2 WAYPOINT3) +(NAVIGATE ROVER0 WAYPOINT3 WAYPOINT0) +(CALIBRATE ROVER0 CAMERA1 OBJECTIVE0 WAYPOINT0) +(TAKE_IMAGE ROVER0 WAYPOINT0 OBJECTIVE0 CAMERA1 COLOUR) +(SAMPLE_ROCK ROVER0 ROVER0STORE WAYPOINT0) +(NAVIGATE ROVER0 WAYPOINT0 WAYPOINT3) +(COMMUNICATE_IMAGE_DATA ROVER0 GENERAL OBJECTIVE0 COLOUR WAYPOINT3 WAYPOINT0) +(COMMUNICATE_ROCK_DATA ROVER0 GENERAL WAYPOINT0 WAYPOINT3 WAYPOINT0) diff --git a/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile3_invalid.plan b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile3_invalid.plan new file mode 100644 index 000000000..36f52ac61 --- /dev/null +++ b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile3_invalid.plan @@ -0,0 +1,7 @@ +(navigate rover1 waypoint3 waypoint0) +(calibrate rover1 camera1 objective0 waypoint0) +(sample_rock rover0 rover0store waypoint0) +(navigate rover1 waypoint0 waypoint3) +(communicate_rock_data rover0 general waypoint0 waypoint1 waypoint0) +(communicate_soil_data rover1 general waypoint2 waypoint2 waypoint0) +(navigate rover1 waypoint2 waypoint3) diff --git a/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile4_invalid.plan b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile4_invalid.plan new file mode 100644 index 000000000..23bafc53e --- /dev/null +++ b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile4_invalid.plan @@ -0,0 +1,4 @@ +(sample_soil rover0 rover0store waypoint3) +(sample_rock rover1 rover1store waypoint1) +(communicate_rock_data rover1 general waypoint1 waypoint1 waypoint2) +(calibrate rover1 camera0 objective0 waypoint1) diff --git a/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan new file mode 100644 index 000000000..5c29d9082 --- /dev/null +++ b/up_test_cases/builtin/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan @@ -0,0 +1,11 @@ +(sample_rock rover0 rover0store waypoint0) +(calibrate rover1 camera1 objective1 waypoint0) +(take_image rover1 waypoint0 objective0 camera1 high_res) +(communicate_image_data rover1 general objective0 high_res waypoint0 waypoint3) +(take_image rover0 waypoint0 objective0 camera2 colour) +(communicate_soil_data rover1 general waypoint1 waypoint1 waypoint3) +(communicate_image_data rover0 general objective2 high_res waypoint0 waypoint3) +(navigate rover1 waypoint1 waypoint2) +(navigate rover1 waypoint2 waypoint1) +(communicate_soil_data rover1 general waypoint2 waypoint1 waypoint3) +(navigate rover0 waypoint1 waypoint0) diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_1_1229.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_1_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_2_1229.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_2_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_3_1229.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_1_3_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_3_3_1229.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_3_3_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_4_10_1229.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_4_10_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_domain.pddl b/up_test_cases/builtin/numeric/sailing/pddl_files/sailing_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile10_invalid.plan b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile10_invalid.plan new file mode 100644 index 000000000..aecb387c6 --- /dev/null +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile10_invalid.plan @@ -0,0 +1,9 @@ +0.0002: (lift hoist5 crate3 crate2 distributor2) [1.0] +0.0002: (lift hoist3 crate5 pallet3 distributor0) [1.0] +0.0002: (lift hoist2 crate4 pallet2 depot2) [1.0] +141.5032: (drive truck0 distributor0 depot0) [1.3333] +29.2525: (drive truck1 distributor2 depot1) [3.0] +3.8345: (drive truck1 depot2 distributor0) [3.5] +32.2528: (load hoist1 crate0 truck1 depot1) [16.0] +48.2533: (drive truck1 depot1 distributor2) [1.5] +67.503: (drop hoist3 crate2 pallet3 distributor0) [1.0] diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile11_invalid.plan b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile11_invalid.plan new file mode 100644 index 000000000..d6f00d8f3 --- /dev/null +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile11_invalid.plan @@ -0,0 +1,15 @@ +0.0002: (drive truck1 distributor0 depot0) [0.6667] +0.0002: (lift hoist0 crate1 pallet0 depot0) [1.0] +177.0015: (lift hoist2 crate4 crate2 depot2) [1.0] +177.0017: (load hoist2 crate4 truck0 depot2) [61.0] +312.0027: (drop hoist2 crate5 pallet2 depot2) [1.0] +391.003: (drive truck0 depot2 distributor0) [0.8889] +391.8921: (drive truck0 distributor0 distributor2) [0.7778] +431.7283: (drop hoist0 crate4 pallet0 depot0) [1.0] +446.9786: (drive truck0 depot0 distributor0) [0.8889] +483.3557: (drive truck0 distributor2 distributor0) [0.5556] +483.9116: (drive truck0 distributor0 depot2) [1.1111] +485.0232: (drop hoist2 crate6 crate5 depot2) [1.0] +486.0221: (drive truck1 depot1 distributor1) [1.1111] +514.0234: (drive truck0 depot2 distributor1) [0.5556] +98.001: (lift hoist2 crate5 crate4 depot2) [1.0] diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1_invalid.plan b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1_invalid.plan new file mode 100644 index 000000000..2dad9e524 --- /dev/null +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1_invalid.plan @@ -0,0 +1,2 @@ +0.1: (lift hoist1 crate0 pallet1 distributor0) [1.1] +43.0013: (drive truck1 depot0 distributor1) [0.875] \ No newline at end of file diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile2_invalid.plan b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile2_invalid.plan new file mode 100644 index 000000000..a6d62307f --- /dev/null +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile2_invalid.plan @@ -0,0 +1,6 @@ +0.0002: (lift hoist2 crate2 crate1 distributor1) [1.0] +33.0008: (lift hoist2 crate1 pallet2 distributor1) [1.0] +33.001: (drive truck0 distributor1 depot0) [3.3333] +49.7798: (drive truck0 depot0 distributor1) [3.3333] +54.4469: (unload hoist2 crate0 truck0 distributor1) [10.6667] +54.4472: (drop hoist2 crate0 pallet2 distributor1) [1.0] diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile3_invalid.plan b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile3_invalid.plan new file mode 100644 index 000000000..d8d7cba2f --- /dev/null +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile3_invalid.plan @@ -0,0 +1,12 @@ +0.0002: (lift hoist0 crate1 pallet0 depot0) [1.0] +0.0002: (lift hoist2 crate5 crate2 distributor1) [1.0] +1.1255: (load hoist0 crate1 truck1 depot0) [22.25] +100.5295: (drive truck1 depot0 distributor1) [0.75] +101.2798: (unload hoist2 crate0 truck1 distributor1) [16.5] +41.552: (drive truck0 distributor0 distributor1) [0.375] +41.552: (load hoist1 crate4 truck1 distributor0) [0.8] +42.3525: (load hoist1 crate3 truck1 distributor0) [16.2] +76.3871: (unload hoist0 crate2 truck0 depot0) [16.75] +78.3535: (drop hoist1 crate4 pallet1 distributor0) [1.0] +80.279: (unload hoist0 crate3 truck1 depot0) [20.25] +80.2793: (drop hoist0 crate3 crate2 depot0) [1.0] diff --git a/up_test_cases/utils.py b/up_test_cases/utils.py index f1e12c8eb..a55924a18 100644 --- a/up_test_cases/utils.py +++ b/up_test_cases/utils.py @@ -66,6 +66,7 @@ def _get_pddl_test_cases( block: Iterable[str] = tuple(), ) -> Dict[str, TestCase]: pddl_files = glob(os.path.join(pddl_files_path, "*.pddl")) + plan_files = glob(os.path.join(pddl_files_path, "*.plan")) domain_filenames: List[str] = [] problem_filenames: List[str] = [] for filename in pddl_files: @@ -86,8 +87,23 @@ def _get_pddl_test_cases( reader = PDDLReader() for problem_filename in problem_filenames: problem = reader.parse_problem(domain_filename, problem_filename) - problem.name = os.path.basename(problem_filename) - res[problem.name] = TestCase(problem=problem, solvable=True) + problem.name = os.path.basename(problem_filename).split(".")[0] + valid_plans = [] + invalid_plans = [] + for plan_file in plan_files: + if problem.name + "_" not in plan_file: + continue + plan = reader.parse_plan(problem, plan_file) + if "invalid" in plan_file: + invalid_plans.append(plan) + else: + valid_plans.append(plan) + res[problem.name] = TestCase( + problem=problem, + solvable=True, + valid_plans=valid_plans, + invalid_plans=invalid_plans, + ) return res From 4ebf340012b73c728b55e469138690652d001a8f Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Thu, 9 Nov 2023 17:15:37 +0100 Subject: [PATCH 08/17] Small changes --- unified_planning/engines/oversubscription_planner.py | 1 - up_test_cases/builtin/classical/depots/__init__.py | 2 +- up_test_cases/builtin/classical/tpp/__init__.py | 2 +- up_test_cases/report.py | 2 +- 4 files changed, 3 insertions(+), 4 deletions(-) diff --git a/unified_planning/engines/oversubscription_planner.py b/unified_planning/engines/oversubscription_planner.py index f66251f75..4f9d08594 100644 --- a/unified_planning/engines/oversubscription_planner.py +++ b/unified_planning/engines/oversubscription_planner.py @@ -171,7 +171,6 @@ def _solve( status, res.plan, self.name, - metrics=res.metrics, log_messages=res.log_messages, ) elif res.status == PlanGenerationResultStatus.TIMEOUT: diff --git a/up_test_cases/builtin/classical/depots/__init__.py b/up_test_cases/builtin/classical/depots/__init__.py index a2b1739f9..e1fcc704a 100644 --- a/up_test_cases/builtin/classical/depots/__init__.py +++ b/up_test_cases/builtin/classical/depots/__init__.py @@ -6,4 +6,4 @@ FILE_DIR = os.path.dirname(os.path.abspath(__file__)) PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") -get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1", "2", "3")) +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1")) diff --git a/up_test_cases/builtin/classical/tpp/__init__.py b/up_test_cases/builtin/classical/tpp/__init__.py index e0cc3d0ea..65f61f2f0 100644 --- a/up_test_cases/builtin/classical/tpp/__init__.py +++ b/up_test_cases/builtin/classical/tpp/__init__.py @@ -8,4 +8,4 @@ # problems_filenames = ["1", "2", "3", "6",] # TODO choose which to keep -get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1", "2", "3")) +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1")) diff --git a/up_test_cases/report.py b/up_test_cases/report.py index 5c3692ffa..7696e19b1 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -79,7 +79,7 @@ def report_runtime( overhead = ( Ok(overhead_str) if overhead_percentage < max_overhead - else Err(overhead_str) + else Warn(overhead_str) ) runtime_report = "{:.3f}s {}".format(total_time, overhead).ljust(30) elif total_time < 1: From 731612d7059799b5d4033069fb86de9992c0370d Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Fri, 10 Nov 2023 10:41:06 +0100 Subject: [PATCH 09/17] Updated performance test cases package --- .../performance/classical/__init__.py | 4 + .../performance/classical/depots/__init__.py | 9 ++ .../depots/pddl_files/depots_domain.pddl | 39 ++++++ .../depots/pddl_files/depots_p02.pddl | 57 +++++++++ .../depots/pddl_files/depots_p02_invalid.plan | 9 ++ .../depots/pddl_files/depots_p03.pddl | 67 +++++++++++ .../depots/pddl_files/depots_p03_invalid.plan | 9 ++ .../performance/classical/tpp/__init__.py | 9 ++ .../classical/tpp/pddl_files/tpp_domain.pddl | 65 ++++++++++ .../classical/tpp/pddl_files/tpp_p02.pddl | 28 +++++ .../tpp/pddl_files/tpp_p02_invalid.plan | 5 + .../classical/tpp/pddl_files/tpp_p03.pddl | 33 ++++++ .../tpp/pddl_files/tpp_p03_invalid.plan | 7 ++ .../classical/tpp/pddl_files/tpp_p06.pddl | 70 +++++++++++ .../tpp/pddl_files/tpp_p06_invalid.plan | 17 +++ .../performance/numeric/block_grouping.py | 111 ++++++++++++++++++ .../pddl_files/depots_pfile10_invalid.plan | 13 ++ .../pddl_files/depots_pfile11_invalid.plan | 53 +++++++++ .../pddl_files/farmland_10_1000_1229.pddl | 0 .../pddl_files/farmland_10_400_1229.pddl | 0 .../farmlands/pddl_files/farmland_domain.pddl | 0 .../fn_counters/pddl_files/fn_counters_8.pddl | 0 .../pddl_files/fn_counters_8_invalid.plan | 40 +++++++ .../pddl_files/fn_counters_domain.pddl | 0 .../pddl_files/plant_watering_4_3.pddl | 0 .../pddl_files/plant_watering_domain.pddl | 0 .../pddl_files/rovers_pfile5_invalid.plan | 11 ++ .../sailing/pddl_files/sailing_4_10_1229.pddl | 0 .../sailing/pddl_files/sailing_domain.pddl | 0 .../pddl_files/depots_pfile10_invalid.plan | 9 ++ .../pddl_files/depots_pfile11_invalid.plan | 15 +++ 31 files changed, 680 insertions(+) create mode 100644 up_test_cases/performance/classical/__init__.py create mode 100644 up_test_cases/performance/classical/depots/__init__.py create mode 100644 up_test_cases/performance/classical/depots/pddl_files/depots_domain.pddl create mode 100644 up_test_cases/performance/classical/depots/pddl_files/depots_p02.pddl create mode 100644 up_test_cases/performance/classical/depots/pddl_files/depots_p02_invalid.plan create mode 100644 up_test_cases/performance/classical/depots/pddl_files/depots_p03.pddl create mode 100644 up_test_cases/performance/classical/depots/pddl_files/depots_p03_invalid.plan create mode 100644 up_test_cases/performance/classical/tpp/__init__.py create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_domain.pddl create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p02.pddl create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p02_invalid.plan create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p03.pddl create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p03_invalid.plan create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p06.pddl create mode 100644 up_test_cases/performance/classical/tpp/pddl_files/tpp_p06_invalid.plan create mode 100644 up_test_cases/performance/numeric/block_grouping.py create mode 100644 up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10_invalid.plan create mode 100644 up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11_invalid.plan mode change 100755 => 100644 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl create mode 100644 up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan mode change 100755 => 100644 up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl create mode 100644 up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan mode change 100755 => 100644 up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl mode change 100755 => 100644 up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl create mode 100644 up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10_invalid.plan create mode 100644 up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11_invalid.plan diff --git a/up_test_cases/performance/classical/__init__.py b/up_test_cases/performance/classical/__init__.py new file mode 100644 index 000000000..18471baa6 --- /dev/null +++ b/up_test_cases/performance/classical/__init__.py @@ -0,0 +1,4 @@ +from functools import partial +from utils import _get_test_cases # type: ignore + +get_test_cases = partial(_get_test_cases, "performance.classical") diff --git a/up_test_cases/performance/classical/depots/__init__.py b/up_test_cases/performance/classical/depots/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/classical/depots/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/classical/depots/pddl_files/depots_domain.pddl b/up_test_cases/performance/classical/depots/pddl_files/depots_domain.pddl new file mode 100644 index 000000000..5858a4e15 --- /dev/null +++ b/up_test_cases/performance/classical/depots/pddl_files/depots_domain.pddl @@ -0,0 +1,39 @@ +(define (domain depot) +(:predicates + (at ?x ?y) (on ?x ?y) (in ?x ?y) (lifting ?x ?y) (available ?x) (clear ?x)(place ?x) (locatable ?x) (depot ?x) (distributor ?x) (truck ?x) (hoist ?x) (surface ?x) (pallet ?x) (crate ?x) ) +(:action drive + :parameters ( ?x ?y ?z) + :precondition + (and (truck ?x) (place ?y) (place ?z) (at ?x ?y)) + :effect + (and (at ?x ?z) (not (at ?x ?y)))) + +(:action lift + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (surface ?z) (place ?p) (at ?x ?p) (available ?x) (at ?y ?p) (on ?y ?z) (clear ?y)) + :effect + (and (lifting ?x ?y) (clear ?z) (not (at ?y ?p)) (not (clear ?y)) (not (available ?x)) (not (on ?y ?z)))) + +(:action drop + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (surface ?z) (place ?p) (at ?x ?p) (at ?z ?p) (clear ?z) (lifting ?x ?y)) + :effect + (and (available ?x) (at ?y ?p) (clear ?y) (on ?y ?z) (not (lifting ?x ?y)) (not (clear ?z)))) + +(:action load + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (truck ?z) (place ?p) (at ?x ?p) (at ?z ?p) (lifting ?x ?y)) + :effect + (and (in ?y ?z) (available ?x) (not (lifting ?x ?y)))) + +(:action unload + :parameters ( ?x ?y ?z ?p) + :precondition + (and (hoist ?x) (crate ?y) (truck ?z) (place ?p) (at ?x ?p) (at ?z ?p) (available ?x) (in ?y ?z)) + :effect + (and (lifting ?x ?y) (not (in ?y ?z)) (not (available ?x)))) + +) diff --git a/up_test_cases/performance/classical/depots/pddl_files/depots_p02.pddl b/up_test_cases/performance/classical/depots/pddl_files/depots_p02.pddl new file mode 100644 index 000000000..421de536f --- /dev/null +++ b/up_test_cases/performance/classical/depots/pddl_files/depots_p02.pddl @@ -0,0 +1,57 @@ +(define (problem depotprob7512) (:domain Depot) +(:objects + depot0 distributor0 distributor1 truck0 truck1 pallet0 pallet1 pallet2 crate0 crate1 crate2 crate3 hoist0 hoist1 hoist2 ) +(:init + (pallet pallet0) + (surface pallet0) + (at pallet0 depot0) + (clear crate0) + (pallet pallet1) + (surface pallet1) + (at pallet1 distributor0) + (clear crate3) + (pallet pallet2) + (surface pallet2) + (at pallet2 distributor1) + (clear crate2) + (truck truck0) + (at truck0 depot0) + (truck truck1) + (at truck1 depot0) + (hoist hoist0) + (at hoist0 depot0) + (available hoist0) + (hoist hoist1) + (at hoist1 distributor0) + (available hoist1) + (hoist hoist2) + (at hoist2 distributor1) + (available hoist2) + (crate crate0) + (surface crate0) + (at crate0 depot0) + (on crate0 pallet0) + (crate crate1) + (surface crate1) + (at crate1 distributor1) + (on crate1 pallet2) + (crate crate2) + (surface crate2) + (at crate2 distributor1) + (on crate2 crate1) + (crate crate3) + (surface crate3) + (at crate3 distributor0) + (on crate3 pallet1) + (place depot0) + (place distributor0) + (place distributor1) +) + +(:goal (and + (on crate0 pallet2) + (on crate1 crate3) + (on crate2 pallet0) + (on crate3 pallet1) + ) +)) diff --git a/up_test_cases/performance/classical/depots/pddl_files/depots_p02_invalid.plan b/up_test_cases/performance/classical/depots/pddl_files/depots_p02_invalid.plan new file mode 100644 index 000000000..1dc6fbc57 --- /dev/null +++ b/up_test_cases/performance/classical/depots/pddl_files/depots_p02_invalid.plan @@ -0,0 +1,9 @@ +(lift hoist0 crate0 pallet0 depot0) +(load hoist2 crate2 truck1 distributor1) +(load hoist0 crate0 truck1 depot0) +(unload hoist0 crate2 truck1 depot0) +(drop hoist0 crate2 pallet0 depot0) +(load hoist2 crate1 truck1 distributor1) +(unload hoist2 crate0 truck1 distributor1) +(drop hoist2 crate0 pallet2 distributor1) +(unload hoist1 crate1 truck1 distributor0) diff --git a/up_test_cases/performance/classical/depots/pddl_files/depots_p03.pddl b/up_test_cases/performance/classical/depots/pddl_files/depots_p03.pddl new file mode 100644 index 000000000..925005b9e --- /dev/null +++ b/up_test_cases/performance/classical/depots/pddl_files/depots_p03.pddl @@ -0,0 +1,67 @@ +(define (problem depotprob1935) (:domain Depot) +(:objects + depot0 distributor0 distributor1 truck0 truck1 pallet0 pallet1 pallet2 crate0 crate1 crate2 crate3 crate4 crate5 hoist0 hoist1 hoist2 ) +(:init + (pallet pallet0) + (surface pallet0) + (at pallet0 depot0) + (clear crate1) + (pallet pallet1) + (surface pallet1) + (at pallet1 distributor0) + (clear crate4) + (pallet pallet2) + (surface pallet2) + (at pallet2 distributor1) + (clear crate5) + (truck truck0) + (at truck0 depot0) + (truck truck1) + (at truck1 distributor0) + (hoist hoist0) + (at hoist0 depot0) + (available hoist0) + (hoist hoist1) + (at hoist1 distributor0) + (available hoist1) + (hoist hoist2) + (at hoist2 distributor1) + (available hoist2) + (crate crate0) + (surface crate0) + (at crate0 distributor0) + (on crate0 pallet1) + (crate crate1) + (surface crate1) + (at crate1 depot0) + (on crate1 pallet0) + (crate crate2) + (surface crate2) + (at crate2 distributor1) + (on crate2 pallet2) + (crate crate3) + (surface crate3) + (at crate3 distributor0) + (on crate3 crate0) + (crate crate4) + (surface crate4) + (at crate4 distributor0) + (on crate4 crate3) + (crate crate5) + (surface crate5) + (at crate5 distributor1) + (on crate5 crate2) + (place depot0) + (place distributor0) + (place distributor1) +) + +(:goal (and + (on crate0 crate1) + (on crate1 pallet2) + (on crate2 pallet0) + (on crate3 crate2) + (on crate4 pallet1) + (on crate5 crate0) + ) +)) diff --git a/up_test_cases/performance/classical/depots/pddl_files/depots_p03_invalid.plan b/up_test_cases/performance/classical/depots/pddl_files/depots_p03_invalid.plan new file mode 100644 index 000000000..1dc6fbc57 --- /dev/null +++ b/up_test_cases/performance/classical/depots/pddl_files/depots_p03_invalid.plan @@ -0,0 +1,9 @@ +(lift hoist0 crate0 pallet0 depot0) +(load hoist2 crate2 truck1 distributor1) +(load hoist0 crate0 truck1 depot0) +(unload hoist0 crate2 truck1 depot0) +(drop hoist0 crate2 pallet0 depot0) +(load hoist2 crate1 truck1 distributor1) +(unload hoist2 crate0 truck1 distributor1) +(drop hoist2 crate0 pallet2 distributor1) +(unload hoist1 crate1 truck1 distributor0) diff --git a/up_test_cases/performance/classical/tpp/__init__.py b/up_test_cases/performance/classical/tpp/__init__.py new file mode 100644 index 000000000..ea78e16c3 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/__init__.py @@ -0,0 +1,9 @@ +import os +from functools import partial + +from utils import _get_pddl_test_cases + +FILE_DIR = os.path.dirname(os.path.abspath(__file__)) +PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") + +get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_domain.pddl b/up_test_cases/performance/classical/tpp/pddl_files/tpp_domain.pddl new file mode 100644 index 000000000..45d378fc2 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_domain.pddl @@ -0,0 +1,65 @@ +; IPC5 Domain: TPP Propositional +; Authors: Alfonso Gerevini and Alessandro Saetti + +(define (domain TPP-Propositional) +(:requirements :strips :typing) +(:types place locatable level - object + depot market - place + truck goods - locatable) + +(:predicates (loaded ?g - goods ?t - truck ?l - level) + (ready-to-load ?g - goods ?m - market ?l - level) + (stored ?g - goods ?l - level) + (on-sale ?g - goods ?m - market ?l - level) + (next ?l1 ?l2 - level) + (at ?t - truck ?p - place) + (connected ?p1 ?p2 - place)) + +(:action drive + :parameters (?t - truck ?from ?to - place) + :precondition (and (at ?t ?from) (connected ?from ?to)) + :effect (and (not (at ?t ?from)) (at ?t ?to))) + + +; ### LOAD ### +; ?l1 is the level of ?g ready to be loaded at ?m before loading +; ?l2 is the level of ?g ready to be loaded at ?m after loading +; ?l3 is the level of ?g in ?t before loading +; ?l4 is the level of ?g in ?t after loading + +(:action load + :parameters (?g - goods ?t - truck ?m - market ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?m) (loaded ?g ?t ?l3) + (ready-to-load ?g ?m ?l2) (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (loaded ?g ?t ?l4) (not (loaded ?g ?t ?l3)) + (ready-to-load ?g ?m ?l1) (not (ready-to-load ?g ?m ?l2)))) + + +; ### UNLOAD ### +; ?l1 is the level of ?g in ?t before unloading +; ?l2 is the level of ?g in ?t after unloading +; ?l3 is the level of ?g in ?d before unloading +; ?l4 is the level of ?g in ?d after unloading + +(:action unload + :parameters (?g - goods ?t - truck ?d - depot ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?d) (loaded ?g ?t ?l2) + (stored ?g ?l3) (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (loaded ?g ?t ?l1) (not (loaded ?g ?t ?l2)) + (stored ?g ?l4) (not (stored ?g ?l3)))) + + +; ### BUY ### +; ?l1 is the level of ?g on sale at ?m before buying +; ?l2 is the level of ?g on sale at ?m after buying +; ?l3 is the level of ?g ready to be loaded at ?m before buying +; ?l4 is the level of ?g ready to be loaded at ?m after buying + +(:action buy + :parameters (?t - truck ?g - goods ?m - market ?l1 ?l2 ?l3 ?l4 - level) + :precondition (and (at ?t ?m) (on-sale ?g ?m ?l2) (ready-to-load ?g ?m ?l3) + (next ?l2 ?l1) (next ?l4 ?l3)) + :effect (and (on-sale ?g ?m ?l1) (not (on-sale ?g ?m ?l2)) + (ready-to-load ?g ?m ?l4) (not (ready-to-load ?g ?m ?l3)))) + +) \ No newline at end of file diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02.pddl b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02.pddl new file mode 100644 index 000000000..c520a4a5b --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02.pddl @@ -0,0 +1,28 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 - goods + truck1 - truck + market1 - market + depot1 - depot + level0 level1 - level) + +(:init + (next level1 level0) + (ready-to-load goods1 market1 level0) + (ready-to-load goods2 market1 level0) + (stored goods1 level0) + (stored goods2 level0) + (loaded goods1 truck1 level0) + (loaded goods2 truck1 level0) + (connected depot1 market1) + (connected market1 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level1) + (at truck1 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level1))) + +) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02_invalid.plan b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02_invalid.plan new file mode 100644 index 000000000..a1bc6a197 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p02_invalid.plan @@ -0,0 +1,5 @@ +(buy truck1 goods2 market1 level0 level1 level0 level1) +(load goods1 truck1 market1 level0 level1 level0 level1) +(drive truck1 market1 depot1) +(drive truck1 depot1 market1) +(drive truck1 market1 depot1) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03.pddl b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03.pddl new file mode 100644 index 000000000..2c9f262b3 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03.pddl @@ -0,0 +1,33 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 goods3 - goods + truck1 - truck + market1 - market + depot1 - depot + level0 level1 - level) + +(:init + (next level1 level0) + (ready-to-load goods1 market1 level0) + (ready-to-load goods2 market1 level0) + (ready-to-load goods3 market1 level0) + (stored goods1 level0) + (stored goods2 level0) + (stored goods3 level0) + (loaded goods1 truck1 level0) + (loaded goods2 truck1 level0) + (loaded goods3 truck1 level0) + (connected depot1 market1) + (connected market1 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level1) + (on-sale goods3 market1 level1) + (at truck1 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level1) + (stored goods3 level1))) + +) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03_invalid.plan b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03_invalid.plan new file mode 100644 index 000000000..f5d8dadac --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p03_invalid.plan @@ -0,0 +1,7 @@ +(buy truck1 goods1 market1 level0 level1 level0 level1) +(buy truck1 goods3 market1 level0 level1 level0 level1) +(load goods1 truck1 market1 level0 level1 level0 level1) +(drive truck1 market1 depot1) +(unload goods2 truck1 depot1 level0 level1 level0 level1) +(drive truck1 depot1 market1) +(drive truck1 market1 depot1) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06.pddl b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06.pddl new file mode 100644 index 000000000..d42c08825 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06.pddl @@ -0,0 +1,70 @@ +(define (problem TPP) +(:domain TPP-Propositional) +(:objects + goods1 goods2 goods3 goods4 goods5 goods6 - goods + truck1 truck2 - truck + market1 market2 - market + depot1 - depot + level0 level1 level2 - level) + +(:init + (next level1 level0) + (next level2 level1) + (ready-to-load goods1 market1 level0) + (ready-to-load goods1 market2 level0) + (ready-to-load goods2 market1 level0) + (ready-to-load goods2 market2 level0) + (ready-to-load goods3 market1 level0) + (ready-to-load goods3 market2 level0) + (ready-to-load goods4 market1 level0) + (ready-to-load goods4 market2 level0) + (ready-to-load goods5 market1 level0) + (ready-to-load goods5 market2 level0) + (ready-to-load goods6 market1 level0) + (ready-to-load goods6 market2 level0) + (stored goods1 level0) + (stored goods2 level0) + (stored goods3 level0) + (stored goods4 level0) + (stored goods5 level0) + (stored goods6 level0) + (loaded goods1 truck1 level0) + (loaded goods1 truck2 level0) + (loaded goods2 truck1 level0) + (loaded goods2 truck2 level0) + (loaded goods3 truck1 level0) + (loaded goods3 truck2 level0) + (loaded goods4 truck1 level0) + (loaded goods4 truck2 level0) + (loaded goods5 truck1 level0) + (loaded goods5 truck2 level0) + (loaded goods6 truck1 level0) + (loaded goods6 truck2 level0) + (connected market1 market2) + (connected market2 market1) + (connected depot1 market2) + (connected market2 depot1) + (on-sale goods1 market1 level1) + (on-sale goods2 market1 level2) + (on-sale goods3 market1 level1) + (on-sale goods4 market1 level2) + (on-sale goods5 market1 level2) + (on-sale goods6 market1 level2) + (on-sale goods1 market2 level0) + (on-sale goods2 market2 level0) + (on-sale goods3 market2 level1) + (on-sale goods4 market2 level0) + (on-sale goods5 market2 level0) + (on-sale goods6 market2 level0) + (at truck1 depot1) + (at truck2 depot1)) + +(:goal (and + (stored goods1 level1) + (stored goods2 level2) + (stored goods3 level1) + (stored goods4 level1) + (stored goods5 level1) + (stored goods6 level1))) + +) diff --git a/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06_invalid.plan b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06_invalid.plan new file mode 100644 index 000000000..5c51ca034 --- /dev/null +++ b/up_test_cases/performance/classical/tpp/pddl_files/tpp_p06_invalid.plan @@ -0,0 +1,17 @@ +(drive truck1 depot1 market2) +(drive truck1 market2 market1) +(buy truck2 goods1 market1 level0 level1 level0 level1) +(buy truck2 goods5 market1 level1 level2 level0 level1) +(load goods1 truck2 market1 level0 level1 level0 level1) +(buy truck2 goods2 market1 level0 level1 level1 level2) +(load goods6 truck2 market1 level0 level1 level0 level1) +(load goods2 truck1 market1 level1 level2 level0 level1) +(drive truck2 market1 market2) +(unload goods2 truck1 depot1 level0 level1 level0 level1) +(unload goods4 truck2 depot1 level0 level1 level0 level1) +(drive truck2 market2 market1) +(drive truck2 market1 market2) +(drive truck2 market2 depot1) +(unload goods3 truck2 depot1 level0 level1 level0 level1) +(drive truck2 market2 depot1) +(unload goods1 truck2 depot1 level0 level1 level0 level1) diff --git a/up_test_cases/performance/numeric/block_grouping.py b/up_test_cases/performance/numeric/block_grouping.py new file mode 100644 index 000000000..8249f63e9 --- /dev/null +++ b/up_test_cases/performance/numeric/block_grouping.py @@ -0,0 +1,111 @@ +from collections import namedtuple +from itertools import chain, combinations +from unified_planning.shortcuts import * +from unified_planning.test import TestCase +import random + +# ProblemMetadata is a data structure that contains the information to create different instance of the "block_grouping" problem. +# since some initial values are created using a random generator, the seed is needed for replication fo the same test. +# groups determines how many block groups there are +ProblemMetadata = namedtuple( + "ProblemMetadata", ["max_coordinate", "blocks_number", "groups", "seed"] +) + +problems_meta_data = [ + ProblemMetadata(11, 10, 2, 4), + ProblemMetadata(20, 25, 3, 5), + ProblemMetadata(20, 25, 4, 6), +] + + +def get_test_cases(): + + res = {} + + base_problem = Problem() + Block = UserType("block") + + x = Fluent("x", RealType(), b=Block) + y = Fluent("y", RealType(), b=Block) + max_x = Fluent("max_x", RealType()) + min_x = Fluent("min_x", RealType()) + max_y = Fluent("max_y", RealType()) + min_y = Fluent("min_y", RealType()) + base_problem.add_fluent(x) + base_problem.add_fluent(y) + base_problem.add_fluent(max_x) + base_problem.add_fluent(min_x, default_initial_value=1) + base_problem.add_fluent(max_y) + base_problem.add_fluent(min_y, default_initial_value=1) + + move_block_up = InstantaneousAction("move_block_up", b=Block) + b = move_block_up.b + move_block_up.add_precondition(LE(Plus(y(b), 1), max_y)) + move_block_up.add_increase_effect(y(b), 1) + + move_block_down = InstantaneousAction("move_block_down", b=Block) + b = move_block_down.b + move_block_down.add_precondition(LE(min_y, Minus(y(b), 1))) + move_block_down.add_decrease_effect(y(b), 1) + + move_block_right = InstantaneousAction("move_block_right", b=Block) + b = move_block_right.b + move_block_right.add_precondition(LE(Plus(x(b), 1), max_x)) + move_block_right.add_increase_effect(x(b), 1) + + move_block_left = InstantaneousAction("move_block_left", b=Block) + b = move_block_left.b + move_block_left.add_precondition(LE(min_x, Minus(x(b), 1))) + move_block_left.add_decrease_effect(x(b), 1) + base_problem.add_actions( + (move_block_up, move_block_down, move_block_right, move_block_left) + ) + + for md in problems_meta_data: + random.seed(md.seed) + problem = base_problem.clone() + problem.name = f"block_grouping_{md.max_coordinate}_{md.blocks_number}_{md.groups}_{md.seed}" + + problem.set_initial_value(max_x, md.max_coordinate) + problem.set_initial_value(max_y, md.max_coordinate) + + # mapping from an object to the objects in the same group + groups: List[List[Object]] = [] + first_elements: List[Object] = [] + + for i in range(md.blocks_number): + block = Object(f"b{i+1}", Block) + if i < md.groups: + groups.append([block]) + first_elements.append(block) + else: + groups[i % md.groups].append(block) + problem.add_object(block) + + for block in chain(*groups): + problem.set_initial_value(x(block), random.randint(1, md.max_coordinate)) + problem.set_initial_value(y(block), random.randint(1, md.max_coordinate)) + + # in the goal, every block in the same group must have same x and y, + # and different groups must have either x or y (or both) different + for block_a, block_b in combinations(first_elements, 2): + problem.add_goal( + Or( + Not(Equals(x(block_a), x(block_b))), + Not(Equals(y(block_a), y(block_b))), + ) + ) + for block_group in groups: + head = block_group[0] + for other_element in block_group[1:]: + problem.add_goal( + And( + Equals(x(head), x(other_element)), + Equals(y(head), y(other_element)), + ) + ) + + # TODO add plans + res[problem.name] = TestCase(problem=problem, solvable=True) + + return res diff --git a/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10_invalid.plan b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10_invalid.plan new file mode 100644 index 000000000..e393da7bf --- /dev/null +++ b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile10_invalid.plan @@ -0,0 +1,13 @@ +(lift hoist5 crate3 crate2 distributor2) +(lift hoist2 crate4 pallet2 depot2) +(lift hoist0 crate1 pallet0 depot0) +(load hoist2 crate4 truck1 depot2) +(drive truck1 depot2 depot1) +(load hoist1 crate4 truck0 depot1) +(drive truck1 depot1 distributor2) +(load hoist5 crate2 truck0 distributor2) +(drop hoist5 crate4 pallet5 distributor2) +(drive truck0 distributor2 distributor0) +(unload hoist5 crate0 truck1 distributor2) +(unload hoist3 crate2 truck0 distributor0) +(drop hoist5 crate0 crate4 distributor2) diff --git a/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11_invalid.plan b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11_invalid.plan new file mode 100644 index 000000000..60cdfd104 --- /dev/null +++ b/up_test_cases/performance/numeric/depots/pddl_files/depots_pfile11_invalid.plan @@ -0,0 +1,53 @@ +(lift hoist2 crate9 crate5 depot2) +(drive truck1 distributor0 depot2) +(lift hoist1 crate3 crate0 depot1) +(lift hoist5 crate8 crate7 distributor2) +(drop hoist2 crate5 crate4 depot2) +(lift hoist2 crate5 crate4 depot2) +(lift hoist2 crate5 crate4 depot2) +(drop hoist2 crate5 crate4 depot2) +(drop hoist1 crate3 crate0 depot1) +(lift hoist1 crate3 crate0 depot1) +(load hoist1 crate3 truck0 depot1) +(lift hoist1 crate0 pallet1 depot1) +(load hoist1 crate0 truck0 depot1) +(drive truck0 depot1 distributor0) +(drive truck0 distributor0 depot2) +(load hoist2 crate0 truck1 depot2) +(drive truck0 depot2 distributor2) +(load hoist5 crate8 truck1 distributor2) +(lift hoist5 crate7 crate6 distributor2) +(load hoist5 crate7 truck1 distributor2) +(load hoist5 crate6 truck1 distributor2) +(unload hoist5 crate2 truck1 distributor2) +(drop hoist5 crate2 pallet5 distributor2) +(unload hoist5 crate5 truck1 distributor2) +(lift hoist5 crate5 crate2 distributor2) +(load hoist5 crate5 truck1 distributor2) +(unload hoist5 crate9 truck0 distributor2) +(drop hoist5 crate9 crate2 distributor2) +(drive truck0 distributor2 depot0) +(drop hoist0 crate7 crate1 depot0) +(drive truck1 depot0 distributor0) +(unload hoist3 crate8 truck1 distributor0) +(lift hoist0 crate7 crate1 depot0) +(drop hoist3 crate8 pallet3 distributor0) +(drop hoist0 crate7 crate1 depot0) +(drive truck1 distributor0 depot0) +(load hoist0 crate7 truck1 depot0) +(lift hoist0 crate1 pallet0 depot0) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(unload hoist5 crate1 truck0 distributor2) +(load hoist5 crate1 truck0 distributor2) +(drive truck0 distributor2 distributor1) +(lift hoist5 crate6 crate5 distributor2) +(drive truck0 distributor2 distributor1) +(unload hoist4 crate7 truck0 distributor1) +(drive truck0 distributor1 depot2) diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_1000_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_10_400_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl b/up_test_cases/performance/numeric/farmlands/pddl_files/farmland_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan new file mode 100644 index 000000000..e9b03b204 --- /dev/null +++ b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_8_invalid.plan @@ -0,0 +1,40 @@ +(increment c6) +(increment c5) +(decrement c3) +(decrement c5) +(decrement c4) +(increment c7) +(increment c2) +(increment c1) +(increment c6) +(increment c7) +(increment c7) +(decrement c6) +(decrement c1) +(decrement c2) +(decrement c6) +(increment c4) +(increment c5) +(increment c3) +(increment c1) +(increment c2) +(decrement c6) +(decrement c4) +(decrement c2) +(increment c6) +(decrement c4) +(increment c3) +(increment c5) +(increment c2) +(decrement c1) +(increment c2) +(increment c4) +(decrement c5) +(increment c6) +(increment c3) +(decrement c4) +(increment c5) +(increment c6) +(decrement c3) +(increment c4) +(decrement c5) diff --git a/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl b/up_test_cases/performance/numeric/fn_counters/pddl_files/fn_counters_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_4_3.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl b/up_test_cases/performance/numeric/plant_watering/pddl_files/plant_watering_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan new file mode 100644 index 000000000..5c29d9082 --- /dev/null +++ b/up_test_cases/performance/numeric/rovers/pddl_files/rovers_pfile5_invalid.plan @@ -0,0 +1,11 @@ +(sample_rock rover0 rover0store waypoint0) +(calibrate rover1 camera1 objective1 waypoint0) +(take_image rover1 waypoint0 objective0 camera1 high_res) +(communicate_image_data rover1 general objective0 high_res waypoint0 waypoint3) +(take_image rover0 waypoint0 objective0 camera2 colour) +(communicate_soil_data rover1 general waypoint1 waypoint1 waypoint3) +(communicate_image_data rover0 general objective2 high_res waypoint0 waypoint3) +(navigate rover1 waypoint1 waypoint2) +(navigate rover1 waypoint2 waypoint1) +(communicate_soil_data rover1 general waypoint2 waypoint1 waypoint3) +(navigate rover0 waypoint1 waypoint0) diff --git a/up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_4_10_1229.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl b/up_test_cases/performance/numeric/sailing/pddl_files/sailing_domain.pddl old mode 100755 new mode 100644 diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10_invalid.plan b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10_invalid.plan new file mode 100644 index 000000000..aecb387c6 --- /dev/null +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10_invalid.plan @@ -0,0 +1,9 @@ +0.0002: (lift hoist5 crate3 crate2 distributor2) [1.0] +0.0002: (lift hoist3 crate5 pallet3 distributor0) [1.0] +0.0002: (lift hoist2 crate4 pallet2 depot2) [1.0] +141.5032: (drive truck0 distributor0 depot0) [1.3333] +29.2525: (drive truck1 distributor2 depot1) [3.0] +3.8345: (drive truck1 depot2 distributor0) [3.5] +32.2528: (load hoist1 crate0 truck1 depot1) [16.0] +48.2533: (drive truck1 depot1 distributor2) [1.5] +67.503: (drop hoist3 crate2 pallet3 distributor0) [1.0] diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11_invalid.plan b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11_invalid.plan new file mode 100644 index 000000000..d6f00d8f3 --- /dev/null +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11_invalid.plan @@ -0,0 +1,15 @@ +0.0002: (drive truck1 distributor0 depot0) [0.6667] +0.0002: (lift hoist0 crate1 pallet0 depot0) [1.0] +177.0015: (lift hoist2 crate4 crate2 depot2) [1.0] +177.0017: (load hoist2 crate4 truck0 depot2) [61.0] +312.0027: (drop hoist2 crate5 pallet2 depot2) [1.0] +391.003: (drive truck0 depot2 distributor0) [0.8889] +391.8921: (drive truck0 distributor0 distributor2) [0.7778] +431.7283: (drop hoist0 crate4 pallet0 depot0) [1.0] +446.9786: (drive truck0 depot0 distributor0) [0.8889] +483.3557: (drive truck0 distributor2 distributor0) [0.5556] +483.9116: (drive truck0 distributor0 depot2) [1.1111] +485.0232: (drop hoist2 crate6 crate5 depot2) [1.0] +486.0221: (drive truck1 depot1 distributor1) [1.1111] +514.0234: (drive truck0 depot2 distributor1) [0.5556] +98.001: (lift hoist2 crate5 crate4 depot2) [1.0] From 364006073ba68659791751244392128e880129ba Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Fri, 10 Nov 2023 11:55:50 +0100 Subject: [PATCH 10/17] Fixed overhead report for anytime --- up_test_cases/report.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/up_test_cases/report.py b/up_test_cases/report.py index 7696e19b1..d8f09e03d 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -441,8 +441,12 @@ def report_anytime( assert isinstance( planner, AnytimePlannerMixin ), "Error in Anytime selection" + results = [] start = time.time() for result in planner.get_solutions(pb, timeout=timeout): + results.append(result) + total_execution_time = time.time() - start + for result in results: status = str(result.status.name).ljust(25) validity, metrics_evaluation = check_result( test_case, result, planner @@ -452,7 +456,6 @@ def report_anytime( metrics_evaluations.append(metrics_evaluation) if not outcome.ok(): errors.append((planner_id, name)) - total_execution_time = time.time() - start if test_case.solvable and planner.ensures( AnytimeGuarantee.INCREASING_QUALITY ): From 4a0e80617b8683a83b27fb715c7efd2564438f73 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Wed, 15 Nov 2023 17:12:09 +0100 Subject: [PATCH 11/17] Updated engines version --- .github/workflows/test.yml | 2 +- setup.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 0b9f819c2..df29e6731 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -12,7 +12,7 @@ env: up_pyperplan_commit: "d6d54f8a8b67e7653599e007a8373245fb2fffd3" up_fast_downward_commit: "090977461c6a55812bc16d5e2df55e556dbbdfb5" up_enhsp_commit: "af93cd799974626ac17b8aaf1a83975f75c073ab" - up_fmap_commit: "98a837f42b9d8d1aaf4c2afe39c9a78cbd5f4043" + up_fmap_commit: "75193633c5e5f70bf83a12731a61e755ab3c2bb0" jobs: basic-check: diff --git a/setup.py b/setup.py index 6a12574ed..2333c25ab 100644 --- a/setup.py +++ b/setup.py @@ -27,8 +27,8 @@ "tamer": ["up-tamer==1.0.0.4.dev1"], "enhsp": ["up-enhsp==0.0.21"], "fast-downward": ["up-fast-downward==0.4.0"], - "lpg": ["up-lpg==0.0.8"], - "fmap": ["up-fmap==0.0.10"], + "lpg": ["up-lpg==0.0.10"], + "fmap": ["up-fmap==0.0.11"], "aries": ["up-aries>=0.2.1"], "symk": ["up-symk>=1.0.1"], "engines": [ @@ -37,8 +37,8 @@ "up-tamer==1.0.0.4.dev1", "up-enhsp==0.0.21", "up-fast-downward==0.4.0", - "up-lpg==0.0.8", - "up-fmap==0.0.10", + "up-lpg==0.0.10", + "up-fmap==0.0.11", "up-aries>=0.2.1", "up-symk>=1.0.1", ], From 9bf5ab8e3b2e6699d9801b311cf2e08b056e9613 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Wed, 15 Nov 2023 17:27:32 +0100 Subject: [PATCH 12/17] Fixed MAPDDLWriter and updated engines version --- .github/workflows/test.yml | 6 +++--- setup.py | 12 ++++++------ unified_planning/io/ma_pddl_writer.py | 18 ++++++++---------- 3 files changed, 17 insertions(+), 19 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index df29e6731..e708aba01 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -8,11 +8,11 @@ on: type: string env: - up_tamer_commit: "db6709d7c465d52db6d1522206b199e30aed23a1" - up_pyperplan_commit: "d6d54f8a8b67e7653599e007a8373245fb2fffd3" + up_tamer_commit: "4d179b5c2722758127bf684d732a6a44431a1732" + up_pyperplan_commit: "6cec570b88d62ca5c4b8029a60c704414fe7f6a9" up_fast_downward_commit: "090977461c6a55812bc16d5e2df55e556dbbdfb5" up_enhsp_commit: "af93cd799974626ac17b8aaf1a83975f75c073ab" - up_fmap_commit: "75193633c5e5f70bf83a12731a61e755ab3c2bb0" + up_fmap_commit: "f29e66c8483abcb8f17ff1c46a0745ee9b1e95fa" jobs: basic-check: diff --git a/setup.py b/setup.py index 2333c25ab..364dd7e4a 100644 --- a/setup.py +++ b/setup.py @@ -23,22 +23,22 @@ "dev": ["tarski[arithmetic]", "pytest", "pytest-cov", "mypy"], "grpc": ["grpcio", "grpcio-tools", "grpc-stubs"], "tarski": ["tarski[arithmetic]"], - "pyperplan": ["up-pyperplan==1.0.0.4.dev1"], - "tamer": ["up-tamer==1.0.0.4.dev1"], + "pyperplan": ["up-pyperplan==1.0.0.6.dev1"], + "tamer": ["up-tamer==1.0.0.6.dev1"], "enhsp": ["up-enhsp==0.0.21"], "fast-downward": ["up-fast-downward==0.4.0"], "lpg": ["up-lpg==0.0.10"], - "fmap": ["up-fmap==0.0.11"], + "fmap": ["up-fmap==0.0.12"], "aries": ["up-aries>=0.2.1"], "symk": ["up-symk>=1.0.1"], "engines": [ "tarski[arithmetic]", - "up-pyperplan==1.0.0.4.dev1", - "up-tamer==1.0.0.4.dev1", + "up-pyperplan==1.0.0.6.dev1", + "up-tamer==1.0.0.6.dev1", "up-enhsp==0.0.21", "up-fast-downward==0.4.0", "up-lpg==0.0.10", - "up-fmap==0.0.11", + "up-fmap==0.0.12", "up-aries>=0.2.1", "up-symk>=1.0.1", ], diff --git a/unified_planning/io/ma_pddl_writer.py b/unified_planning/io/ma_pddl_writer.py index 818d6de8e..0d33fa823 100644 --- a/unified_planning/io/ma_pddl_writer.py +++ b/unified_planning/io/ma_pddl_writer.py @@ -760,28 +760,26 @@ def get_ma_problem_agent(self, agent_name) -> str: def write_ma_domain(self, directory_name): """Dumps to file the `MA-PDDL` domains.""" ag_domains = self._write_domain() - outdir_ma_pddl = "ma_pddl_" + directory_name - osy.makedirs(outdir_ma_pddl, exist_ok=True) + osy.makedirs(directory_name, exist_ok=True) for ag, domain in ag_domains.items(): if not self.unfactored: - name_domain = ag + name_domain = ag + "_" else: - name_domain = _get_pddl_name(self.problem) - path_ma_pddl = osy.path.join(outdir_ma_pddl, name_domain + "_domain.pddl") + name_domain = "" + path_ma_pddl = osy.path.join(directory_name, name_domain + "domain.pddl") with open(path_ma_pddl, "w") as f: f.write(domain) def write_ma_problem(self, directory_name): """Dumps to file the `MA-PDDL` problems.""" ag_problems = self._write_problem() - outdir_ma_pddl = "ma_pddl_" + directory_name - osy.makedirs(outdir_ma_pddl, exist_ok=True) + osy.makedirs(directory_name, exist_ok=True) for ag, problem in ag_problems.items(): if not self.unfactored: - name_problem = ag + name_problem = ag + "_" else: - name_problem = _get_pddl_name(self.problem) - path_ma_pddl = osy.path.join(outdir_ma_pddl, name_problem + "_problem.pddl") + name_problem = "" + path_ma_pddl = osy.path.join(directory_name, name_problem + "problem.pddl") with open(path_ma_pddl, "w") as f: f.write(problem) From bc6b0a17d01a1ecbdd9c94e2f4f2d7eb6c003965 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Thu, 16 Nov 2023 12:02:16 +0100 Subject: [PATCH 13/17] Updated depot problem --- .../builtin/temporal/depot/pddl_files/depots_pfile1.pddl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1.pddl b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1.pddl index e391f18b2..038ed6a86 100644 --- a/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1.pddl +++ b/up_test_cases/builtin/temporal/depot/pddl_files/depots_pfile1.pddl @@ -22,13 +22,13 @@ (= (power hoist0) 2) (at hoist1 distributor0) (available hoist1) - (= (power hoist1) 9) + (= (power hoist1) 8) (at hoist2 distributor1) (available hoist2) (= (power hoist2) 6) (at crate0 distributor0) (on crate0 pallet1) - (= (weight crate0) 11) + (= (weight crate0) 12) (at crate1 depot0) (on crate1 pallet0) (= (weight crate1) 86) From e3259e0dbdf9b401a2e1b0a2d20db91f0bc81a18 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Tue, 21 Nov 2023 14:52:35 +0100 Subject: [PATCH 14/17] Allowing to adjust for docker_overhead_time in report.py --- up_test_cases/report.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/up_test_cases/report.py b/up_test_cases/report.py index d8f09e03d..f7efd6443 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -64,14 +64,23 @@ def get_test_cases_from_packages(packages: List[str]) -> Dict[str, TestCase]: def report_runtime( - metrics: Optional[Dict[str, str]], total_time: float, max_overhead: float + metrics: Optional[Dict[str, str]], + total_time: float, + max_overhead: float, + adjust_docker_overhead: bool = True, ) -> str: internal_time_str = None if metrics is not None: internal_time_str = metrics.get("engine_internal_time", None) + docker_overhead_time_str = metrics.get("docker_overhead_time", None) if internal_time_str is not None: internal_time = float(internal_time_str) - overhead_percentage = (total_time - internal_time) / internal_time + docker_overhead_time = 0.0 + if adjust_docker_overhead and docker_overhead_time_str is not None: + docker_overhead_time = float(docker_overhead_time_str) + overhead_percentage = ( + total_time - docker_overhead_time - internal_time + ) / internal_time else: overhead_percentage = None if total_time > 1 and overhead_percentage is not None: From fa5a9ace16be08840efbc0128de7b118894aa054 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Tue, 21 Nov 2023 16:41:46 +0100 Subject: [PATCH 15/17] Updated depot problems --- .../depot/pddl_files/depots_pfile10.pddl | 8 ++++---- .../depot/pddl_files/depots_pfile11.pddl | 18 +++++++++--------- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl index 50f647dc0..ffdfc12ac 100644 --- a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile10.pddl @@ -20,7 +20,7 @@ (at pallet5 distributor2) (clear crate3) (at truck0 depot1) - (= (speed truck0) 3) + (= (speed truck0) 4) (at truck1 depot2) (= (speed truck1) 2) (at hoist0 depot0) @@ -31,7 +31,7 @@ (= (power hoist1) 6) (at hoist2 depot2) (available hoist2) - (= (power hoist2) 6) + (= (power hoist2) 4) (at hoist3 distributor0) (available hoist3) (= (power hoist3) 1) @@ -55,7 +55,7 @@ (= (weight crate3) 16) (at crate4 depot2) (on crate4 pallet2) - (= (weight crate4) 23) + (= (weight crate4) 24) (at crate5 distributor0) (on crate5 pallet3) (= (weight crate5) 42) @@ -76,7 +76,7 @@ (= (distance depot2 depot2) 0) (= (distance depot2 distributor0) 7) (= (distance depot2 distributor1) 2) - (= (distance depot2 distributor2) 4) + (= (distance depot2 distributor2) 6) (= (distance distributor0 depot0) 4) (= (distance distributor0 depot1) 10) (= (distance distributor0 depot2) 6) diff --git a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl index fdc10a12d..b664fbc20 100644 --- a/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl +++ b/up_test_cases/performance/temporal/depot/pddl_files/depots_pfile11.pddl @@ -20,9 +20,9 @@ (at pallet5 distributor2) (clear crate8) (at truck0 depot2) - (= (speed truck0) 9) + (= (speed truck0) 10) (at truck1 distributor0) - (= (speed truck1) 9) + (= (speed truck1) 10) (at hoist0 depot0) (available hoist0) (= (power hoist0) 4) @@ -49,28 +49,28 @@ (= (weight crate1) 6) (at crate2 depot2) (on crate2 pallet2) - (= (weight crate2) 74) + (= (weight crate2) 75) (at crate3 depot1) (on crate3 crate0) - (= (weight crate3) 64) + (= (weight crate3) 63) (at crate4 depot2) (on crate4 crate2) (= (weight crate4) 61) (at crate5 depot2) (on crate5 crate4) - (= (weight crate5) 79) + (= (weight crate5) 80) (at crate6 distributor2) (on crate6 pallet5) - (= (weight crate6) 29) + (= (weight crate6) 30) (at crate7 distributor2) (on crate7 crate6) - (= (weight crate7) 77) + (= (weight crate7) 78) (at crate8 distributor2) (on crate8 crate7) - (= (weight crate8) 19) + (= (weight crate8) 18) (at crate9 depot2) (on crate9 crate5) - (= (weight crate9) 98) + (= (weight crate9) 102) (= (distance depot0 depot0) 0) (= (distance depot0 depot1) 1) (= (distance depot0 depot2) 7) From 09778a7e95dd7dd68d94c62fbe54d6c4554d20d3 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Thu, 23 Nov 2023 17:36:40 +0100 Subject: [PATCH 16/17] Updated aries version --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 364dd7e4a..170179ee4 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,7 @@ "fast-downward": ["up-fast-downward==0.4.0"], "lpg": ["up-lpg==0.0.10"], "fmap": ["up-fmap==0.0.12"], - "aries": ["up-aries>=0.2.1"], + "aries": ["up-aries>=0.3.1"], "symk": ["up-symk>=1.0.1"], "engines": [ "tarski[arithmetic]", @@ -39,7 +39,7 @@ "up-fast-downward==0.4.0", "up-lpg==0.0.10", "up-fmap==0.0.12", - "up-aries>=0.2.1", + "up-aries>=0.3.1", "up-symk>=1.0.1", ], "plot": [ From e856419ca6ff6c612d63defb47a769dde1384318 Mon Sep 17 00:00:00 2001 From: Alessandro Valentini Date: Mon, 4 Dec 2023 17:58:31 +0100 Subject: [PATCH 17/17] Minor changes after @arbimo review --- .../builtin/classical/tpp/__init__.py | 2 - .../builtin/numeric/block_grouping.py | 6 -- up_test_cases/report.py | 80 +++++++++++++------ up_test_cases/utils.py | 8 ++ 4 files changed, 64 insertions(+), 32 deletions(-) diff --git a/up_test_cases/builtin/classical/tpp/__init__.py b/up_test_cases/builtin/classical/tpp/__init__.py index 65f61f2f0..e1fcc704a 100644 --- a/up_test_cases/builtin/classical/tpp/__init__.py +++ b/up_test_cases/builtin/classical/tpp/__init__.py @@ -6,6 +6,4 @@ FILE_DIR = os.path.dirname(os.path.abspath(__file__)) PDDL_FILES_DIR = os.path.join(FILE_DIR, "pddl_files") -# problems_filenames = ["1", "2", "3", "6",] # TODO choose which to keep - get_test_cases = partial(_get_pddl_test_cases, PDDL_FILES_DIR, filter=("1")) diff --git a/up_test_cases/builtin/numeric/block_grouping.py b/up_test_cases/builtin/numeric/block_grouping.py index 6931cdeea..20cdf41eb 100644 --- a/up_test_cases/builtin/numeric/block_grouping.py +++ b/up_test_cases/builtin/numeric/block_grouping.py @@ -13,11 +13,6 @@ problems_meta_data = [ ProblemMetadata(5, 5, 1, 1), - # ProblemMetadata(5, 5, 2, 2), # TODO choose which to keep - # ProblemMetadata(5, 5, 2, 3), - # ProblemMetadata(11, 10, 2, 4), - # ProblemMetadata(20, 25, 3, 5), - # ProblemMetadata(20, 25, 4, 6), ] @@ -108,7 +103,6 @@ def get_test_cases(): ) ) - # TODO add plans res[problem.name] = TestCase(problem=problem, solvable=True) return res diff --git a/up_test_cases/report.py b/up_test_cases/report.py index f7efd6443..aea024e8c 100644 --- a/up_test_cases/report.py +++ b/up_test_cases/report.py @@ -68,6 +68,7 @@ def report_runtime( total_time: float, max_overhead: float, adjust_docker_overhead: bool = True, + deliverable: bool = False, ) -> str: internal_time_str = None if metrics is not None: @@ -83,18 +84,26 @@ def report_runtime( ) / internal_time else: overhead_percentage = None - if total_time > 1 and overhead_percentage is not None: - overhead_str = "{:.0%}".format(overhead_percentage) - overhead = ( - Ok(overhead_str) - if overhead_percentage < max_overhead - else Warn(overhead_str) - ) - runtime_report = "{:.3f}s {}".format(total_time, overhead).ljust(30) - elif total_time < 1: - runtime_report = "{:.3f}s {}".format(total_time, Ok("<1s")).ljust(30) + if deliverable: + if total_time > 1 and overhead_percentage is not None: + overhead_str = "{:.0%}".format(overhead_percentage) + overhead = ( + Ok(overhead_str) + if overhead_percentage < max_overhead + else Warn(overhead_str) + ) + runtime_report = "{:.3f}s {}".format(total_time, overhead).ljust(30) + elif total_time < 1: + runtime_report = "{:.3f}s {}".format(total_time, Ok("<1s")).ljust(30) + else: + runtime_report = "{:.3f}s".format(total_time).ljust(30) else: - runtime_report = "{:.3f}s".format(total_time).ljust(21) + if internal_time_str is not None: + runtime_report = "{:.3f}s ({:.3f}s)".format( + total_time, internal_time + ).ljust(30) + else: + runtime_report = "{:.3f}s".format(total_time).ljust(30) return runtime_report @@ -238,7 +247,10 @@ def check_grounding_result(test: TestCase, result: CompilerResult) -> ResultSet: def report_oneshot( - engines: List[str], problems: Dict[str, TestCase], timeout: Optional[float] + engines: List[str], + problems: Dict[str, TestCase], + timeout: Optional[float], + deliverable, ) -> List[Tuple[str, str]]: """Run all oneshot planners on all the given problems""" @@ -296,7 +308,10 @@ def report_oneshot( if not outcome.ok(): errors.append((planner_id, name)) runtime_report = report_runtime( - result.metrics, total_execution_time, 0.10 + result.metrics, + total_execution_time, + 0.10, + deliverable=deliverable, ) print(status, " ", runtime_report, outcome) @@ -316,7 +331,7 @@ def report_oneshot( def report_plan_repair( - engines: List[str], problems: Dict[str, TestCase] + engines: List[str], problems: Dict[str, TestCase], deliverable: bool ) -> List[Tuple[str, str]]: """Run all plan repairer on all the given problems""" @@ -357,7 +372,10 @@ def report_plan_repair( if not outcome.ok(): errors.append((planner_id, f"{name} [{i}]")) runtime_report = report_runtime( - result.metrics, total_execution_time, 0.10 + result.metrics, + total_execution_time, + 0.10, + deliverable=deliverable, ) print(status, " ", runtime_report, outcome) @@ -417,7 +435,10 @@ def check_all_optimal_solutions( def report_anytime( - engines: List[str], problems: Dict[str, TestCase], timeout: Optional[float] + engines: List[str], + problems: Dict[str, TestCase], + timeout: Optional[float], + deliverable: bool, ) -> List[Tuple[str, str]]: """Run all anytime planners on all problems that start with the given prefix""" @@ -478,7 +499,10 @@ def report_anytime( test_case, metrics_evaluations ) runtime_report = report_runtime( - result.metrics, total_execution_time, 0.15 + result.metrics, + total_execution_time, + 0.15, + deliverable=deliverable, ) print(status, " ", runtime_report, outcome) @@ -499,7 +523,7 @@ def report_anytime( def report_validation( - engines: List[str], problems: Dict[str, TestCase] + engines: List[str], problems: Dict[str, TestCase], deliverable: bool ) -> List[Tuple[str, str]]: """Checks that all given plan validators produce the correct output on test-cases.""" factory = get_environment().factory @@ -533,7 +557,7 @@ def applicable_validators(pb, plan): total_execution_time = time.time() - start print(str(result.status.name).ljust(25), end=" ") runtime_report = report_runtime( - result.metrics, total_execution_time, 0.05 + result.metrics, total_execution_time, 0.05, deliverable=deliverable ) print(runtime_report, end="") if result.status == ValidationResultStatus.VALID: @@ -558,7 +582,7 @@ def applicable_validators(pb, plan): total_execution_time = time.time() - start print(str(result.status.name).ljust(25), end=" ") runtime_report = report_runtime( - result.metrics, total_execution_time, 0.05 + result.metrics, total_execution_time, 0.05, deliverable=deliverable ) print(runtime_report, end="") if result.status == ValidationResultStatus.INVALID: @@ -681,17 +705,25 @@ def main(): grounding_errors = [] repair_errors = [] + deliverable = parsed_args.deliverable + with warnings.catch_warnings(): warnings.simplefilter("ignore") if "oneshot" in modes: - oneshot_errors = report_oneshot(engines, problem_test_cases, timeout) + oneshot_errors = report_oneshot( + engines, problem_test_cases, timeout, deliverable + ) if "anytime" in modes: - anytime_errors = report_anytime(engines, problem_test_cases, timeout) + anytime_errors = report_anytime( + engines, problem_test_cases, timeout, deliverable + ) if "repair" in modes: - repair_errors = report_plan_repair(engines, problem_test_cases) + repair_errors = report_plan_repair(engines, problem_test_cases, deliverable) if "validation" in modes: - validation_errors = report_validation(engines, problem_test_cases) + validation_errors = report_validation( + engines, problem_test_cases, deliverable + ) if "grounding" in modes: grounding_errors = report_grounding(engines, problem_test_cases) diff --git a/up_test_cases/utils.py b/up_test_cases/utils.py index a55924a18..8593b941c 100644 --- a/up_test_cases/utils.py +++ b/up_test_cases/utils.py @@ -253,4 +253,12 @@ def get_report_parser() -> argparse.ArgumentParser: default=DEFAULT_TIMEOUT, ) + parser.add_argument( + "-d", + "--deliverable", + action="store_true", + dest="deliverable", + help=f"Adds information needed in the evaluation report", + ) + return parser