def create_domain(goal_facts):
domain = make_domain()
for fact in goal_facts: # TODO: consider removing this annoying check
name = get_prefix(fact)
parameters = ['?x{}'.format(i) for i in range(len(get_args(fact)))]
add_predicate(domain, make_predicate(name, parameters))
return domain
def instantiate_optimizer_axioms(instantiated, domain, results):
# Needed for instantiating axioms before adding stream action effects
# Otherwise, FastDownward will prune these unreachable axioms
# TODO: compute this first and then apply the eager actions
stream_init = {
fd_from_fact(result.stream_fact)
for result in results if isinstance(result, StreamResult)
}
evaluations = list(
map(evaluation_from_fd, stream_init | instantiated.atoms))
temp_domain = make_domain(
predicates=[make_predicate(UNSATISFIABLE, [])],
axioms=[ax for ax in domain.axioms if ax.name == UNSATISFIABLE])
temp_problem = get_problem(evaluations, Not((UNSATISFIABLE, )),
temp_domain)
# TODO: UNSATISFIABLE might be in atoms making the goal always infeasible
with Verbose():
# TODO: the FastDownward instantiation prunes static preconditions
use_fd = False if using_optimizers(results) else FD_INSTANTIATE
new_instantiated = instantiate_task(task_from_domain_problem(
temp_domain, temp_problem),
use_fd=use_fd,
check_infeasible=False,
prune_static=False)
assert new_instantiated is not None
instantiated.axioms.extend(new_instantiated.axioms)
instantiated.atoms.update(new_instantiated.atoms)
def add_stream_actions(domain, results, **kwargs):
stream_actions, result_from_name = get_stream_actions(results, **kwargs)
output_objects = []
for result in result_from_name.values():
if isinstance(result, StreamResult):
output_objects.extend(map(pddl_from_object, result.output_objects))
new_constants = list(
make_parameters(set(output_objects) | set(domain.constants)))
# to_untyped_strips, free_variables
new_domain = make_domain(constants=new_constants,
predicates=domain.predicates,
actions=domain.actions[:] + stream_actions,
axioms=domain.axioms)
#new_domain = copy.copy(domain)
"""
optimizer_results = list(filter(is_optimizer_result, stream_results))
optimizer_facts = {substitute_expression(result.external.stream_fact, result.get_mapping())
for result in optimizer_results}
optimizers = {result.external.optimizer for result in optimizer_results}
print(optimizers)
for optimizer in optimizers:
for stream in optimizer.streams:
print(stream.instance.get_constraints())
print(stream.instance)
#print(optimizer_results)
#print(optimizer_facts)
"""
return new_domain, result_from_name
def add_stream_actions(domain, results, **kwargs):
if not results:
return domain, {}
stream_actions, result_from_name = get_stream_actions(results, **kwargs)
output_objects = []
for result in result_from_name.values():
if isinstance(result, StreamResult):
output_objects.extend(map(pddl_from_object, result.output_objects))
new_constants = list(make_parameters(set(output_objects) | set(domain.constants)))
# to_untyped_strips, free_variables
new_domain = make_domain(constants=new_constants, predicates=domain.predicates,
actions=domain.actions[:] + stream_actions, axioms=domain.axioms)
#new_domain = copy.copy(domain)
return new_domain, result_from_name
def planning_from_satisfaction(init, constraints):
clusters = cluster_constraints(constraints)
prefix = get_internal_prefix(internal=False)
assigned_predicate = ASSIGNED_PREDICATE.format(prefix)
order_predicate = ORDER_PREDICATE.format(prefix)
#order_value_facts = make_order_facts(order_predicate, 0, len(clusters)+1)
order_value_facts = [(order_predicate, '_t{}'.format(i))
for i in range(len(clusters) + 1)]
init.append(order_value_facts[0])
goal_expression = order_value_facts[-1]
order_facts = list(map(obj_from_value_expression, order_value_facts))
bound_parameters = set()
actions = []
#constants = {}
for i, cluster in enumerate(clusters):
objectives = list(map(obj_from_value_expression, cluster.constraints))
constraints, negated, costs = partition_facts(objectives)
if negated:
raise NotImplementedError(negated)
#free_parameters = cluster.parameters - bound_parameters
existing_parameters = cluster.parameters & bound_parameters
# TODO: confirm that negated predicates work as intended
name = 'cluster-{}'.format(i)
parameters = list(sorted(cluster.parameters))
preconditions = [(assigned_predicate, to_constant(p), p) for p in sorted(existing_parameters)] + \
constraints + [order_facts[i]]
effects = [(assigned_predicate, to_constant(p), p) for p in parameters] + \
[order_facts[i+1], Not(order_facts[i])]
if costs:
assert len(costs) == 1
[cost] = costs
else:
cost = None
actions.append(
make_action(name, parameters, preconditions, effects, cost))
#actions[-1].dump()
bound_parameters.update(cluster.parameters)
predicates = [make_predicate(order_predicate, ['?step'])] # '?num',
domain = make_domain(predicates=predicates, actions=actions)
return domain, goal_expression
def planning_from_satisfaction(init, constraints):
clusters = cluster_constraints(constraints)
order_value_facts = [(ORDER_PREDICATE, 't{}'.format(i))
for i in range(len(clusters) + 1)]
init.append(order_value_facts[0])
goal_expression = order_value_facts[-1]
order_facts = list(map(obj_from_value_expression, order_value_facts))
bound_parameters = set()
actions = []
#constants = {}
for i, cluster in enumerate(clusters):
objectives = list(map(obj_from_value_expression, cluster.constraints))
#free_parameters = cluster.parameters - bound_parameters
existing_parameters = cluster.parameters & bound_parameters
# TODO: confirm that negated predicates work as intended
name = 'cluster-{}'.format(i)
parameters = list(sorted(cluster.parameters))
preconditions = [(ASSIGNED_PREDICATE, to_constant(p), p) for p in sorted(existing_parameters)] + \
get_constraints(objectives) + [order_facts[i]]
effects = [(ASSIGNED_PREDICATE, to_constant(p), p) for p in parameters] + \
[order_facts[i+1], Not(order_facts[i])]
costs = get_costs(objectives)
cost = None
if costs:
assert len(costs) == 1
cost = get_args(costs[0])[0]
actions.append(
make_action(name, parameters, preconditions, effects, cost))
#actions[-1].dump()
bound_parameters.update(cluster.parameters)
predicates = [make_predicate(ORDER_PREDICATE, ['?x'])]
domain = make_domain(predicates=predicates, actions=actions)
return domain, goal_expression