def reinstantiate_action_instances(task, old_instances):
import pddl
import instantiate
# Recomputes the instances with without any pruned preconditions
fluents = get_fluents(task)
function_assignments = {
fact.fluent: fact.expression
for fact in task.init
if isinstance(fact, pddl.f_expression.FunctionAssignment)
}
type_to_objects = instantiate.get_objects_by_type(task.objects, task.types)
init_facts = set()
fluent_facts = MockSet()
new_instances = []
state = set(task.init)
for old_instance in old_instances:
# TODO: better way of instantiating conditional effects (when not fluent)
#new_instance = reinstantiate_action(old_instance)
predicate_to_atoms = instantiate.get_atoms_by_predicate({
a
for a in state
if isinstance(a, pddl.Atom) and (a.predicate in fluents)
})
action = old_instance.action
var_mapping = old_instance.var_mapping
new_instance = action.instantiate(var_mapping, init_facts,
fluent_facts, type_to_objects,
task.use_min_cost_metric,
function_assignments,
predicate_to_atoms)
assert (new_instance is not None)
new_instances.append(new_instance)
apply_action(state, new_instance)
new_instances.append(get_goal_instance(task.goal)) # TODO: move this?
return new_instances
def reinstantiate_action_instances(task, old_instances):
import pddl
import instantiate
# Recomputes the instances with without any pruned preconditions
function_assignments = {
fact.fluent: fact.expression
for fact in task.init
if isinstance(fact, pddl.f_expression.FunctionAssignment)
}
type_to_objects = instantiate.get_objects_by_type(task.objects, task.types)
init_facts = set()
fluent_facts = MockSet()
new_instances = []
for old_instance in old_instances:
action = old_instance.action
#if action is None:
# new_instances.append(old_instance) # goal_instance
var_mapping = old_instance.var_mapping
new_instance = action.instantiate(var_mapping, init_facts,
fluent_facts, type_to_objects,
task.use_min_cost_metric,
function_assignments)
assert (new_instance is not None)
new_instances.append(new_instance)
new_instances.append(get_goal_instance(task.goal)) # TODO: move this?
return new_instances
def recover_axioms_plans(instantiated, action_instances):
task = instantiated.task
derived_predicates = get_derived_predicates(task.axioms)
state = set(task.init)
axiom_plans = []
for action_instance in action_instances + [get_goal_instance(task.goal)]:
# TODO: apply all axiom_instances unaffected by negative conditions
preimage = list(plan_preimage([action_instance], []))
axiom_instances = filter(
lambda ax: all(l.predicate in derived_predicates or literal_holds(
state, l) for l in ax.condition), instantiated.axioms)
# Only instantiate if preimage has goal
axiom_plan = extraction_helper(state, axiom_instances, preimage)
assert axiom_plan is not None
axiom_plans.append(axiom_plan)
apply_action(state, action_instance)
return axiom_plans
def is_solution(domain, evaluations, action_plan, goal_expression):
task = task_from_domain_problem(
domain,
get_problem(evaluations, goal_expression, domain, unit_costs=True))
action_instances = get_action_instances(
task, action_plan) + [get_goal_instance(task.goal)]
#original_init = task.init
task.init = set(task.init)
for instance in action_instances:
axiom_plan = extract_axiom_plan(task,
instance,
negative_from_name={},
static_state=task.init)
if axiom_plan is None:
return False
#substitute_derived(axiom_plan, instance)
#if not is_applicable(task.init, instance):
# return False
apply_action(task.init, instance)
return True
def instantiate_actions(opt_task, type_to_objects, function_assignments, action_plan):
action_instances = []
for name, args in action_plan: # TODO: negative atoms in actions
candidates = []
for action in opt_task.actions:
if action.name != name:
continue
if len(action.parameters) != len(args):
raise NotImplementedError('Existential quantifiers are not currently '
'supported in preconditions: {}'.format(name))
variable_mapping = {p.name: a for p, a in zip(action.parameters, args)}
action_instance = action.instantiate(variable_mapping, set(), MockSet(), type_to_objects,
opt_task.use_min_cost_metric, function_assignments)
assert (action_instance is not None)
candidates.append(((action, args), action_instance))
if not candidates:
raise RuntimeError('Could not find an applicable action {}'.format(name))
action_instances.append(candidates)
action_instances.append([(None, get_goal_instance(opt_task.goal))])
return action_instances
def recover_opt_stream_plan(evaluations, action_plan, task):
plan_instances = get_action_instances(task, action_plan) + [get_goal_instance(task.goal)]
replace_derived(task, set(), plan_instances)
preimage = filter(lambda a: not a.negated, plan_preimage(plan_instances, []))
opt_stream_plan = []
opt_from_obj = {}
for stream_result in extract_order(evaluations, preimage):
input_objects = tuple(opt_from_obj.get(o, o) for o in stream_result.instance.input_objects)
instance = stream_result.instance.external.get_instance(input_objects)
#instance.opt_index = stream_result.instance.opt_index
#assert(instance.opt_index == 0)
instance.opt_index = 0
#assert(not instance.disabled)
instance.disabled = False
opt_results = instance.next_optimistic()
if not opt_results:
continue
opt_result = opt_results[0]
opt_stream_plan.append(opt_result)
for obj, opt in zip(stream_result.output_objects, opt_result.output_objects):
opt_from_obj[obj] = opt
return opt_stream_plan, opt_from_obj