def get_problem(evaluations, goal_exp, domain, unit_costs=False):
objects = objects_from_evaluations(evaluations)
typed_objects = list(
{make_object(pddl_from_object(obj))
for obj in objects} - set(domain.constants))
# TODO: this doesn't include =
init = [
fd_from_evaluation(e) for e in evaluations if not is_negated_atom(e)
]
goal = pddl.Truth() if goal_exp is None else parse_goal(goal_exp, domain)
problem_pddl = None
if USE_FORBID:
problem_pddl = get_problem_pddl(evaluations,
goal_exp,
domain.pddl,
temporal=False)
write_pddl(domain.pddl, problem_pddl)
return Problem(task_name=domain.name,
task_domain_name=domain.name,
objects=sorted(typed_objects, key=lambda o: o.name),
task_requirements=pddl.tasks.Requirements([]),
init=init,
goal=goal,
use_metric=not unit_costs,
pddl=problem_pddl)
def get_problem(init_evaluations, goal_expression, domain, unit_costs=False):
objects = objects_from_evaluations(init_evaluations)
typed_objects = list({pddl.TypedObject(pddl_from_object(obj), OBJECT) for obj in objects} - set(domain.constants))
# TODO: this doesn't include =
init = [fd_from_evaluation(e) for e in init_evaluations if not is_negated_atom(e)]
goal = parse_goal(goal_expression, domain)
return Problem(task_name=domain.name, task_domain_name=domain.name, objects=sorted(typed_objects, key=lambda o: o.name),
task_requirements=pddl.tasks.Requirements([]), init=init, goal=goal, use_metric=not unit_costs)
def fd_from_evaluation(evaluation):
name = evaluation.head.function
args = tuple(map(pddl_from_object, evaluation.head.args))
if is_atom(evaluation):
return pddl.Atom(name, args)
elif is_negated_atom(evaluation):
return pddl.NegatedAtom(name, args)
fluent = pddl.f_expression.PrimitiveNumericExpression(symbol=name, args=args)
expression = pddl.f_expression.NumericConstant(evaluation.value)
return pddl.f_expression.Assign(fluent, expression)
def pddl_from_evaluation(evaluation):
#if evaluation.head.function == TOTAL_COST:
# return None
head = pddl_head(evaluation.head.function, evaluation.head.args)
if is_atom(evaluation):
return head
elif is_negated_atom(evaluation):
return '(not {})'.format(head)
#value = int(evaluation.value)
value = evaluation.value # floats are fine for temporal planners
#value = int(math.ceil(evaluation.value))
return '(= {} {})'.format(head, value)
def get_init(init_evaluations, negated=False):
# TODO: this doesn't include =
init = []
for evaluation in init_evaluations:
name = evaluation.head.function
args = tuple(map(pddl_from_object, evaluation.head.args))
if is_atom(evaluation):
init.append(pddl.Atom(name, args))
elif negated and is_negated_atom(evaluation):
init.append(pddl.NegatedAtom(name, args))
else:
fluent = pddl.f_expression.PrimitiveNumericExpression(symbol=name,
args=args)
expression = pddl.f_expression.NumericConstant(
evaluation.value) # Integer
init.append(pddl.f_expression.Assign(fluent, expression))
return init
def get_achieving_streams(evaluations,
stream_results,
max_effort=INF,
**effort_args):
unprocessed_from_atom = defaultdict(list)
node_from_atom = {NULL_COND: Node(0, None)}
conditions_from_stream = {}
remaining_from_stream = {}
for result in stream_results:
conditions_from_stream[result] = result.instance.get_domain() + (
NULL_COND, )
remaining_from_stream[result] = len(conditions_from_stream[result])
for atom in conditions_from_stream[result]:
unprocessed_from_atom[atom].append(result)
for atom in evaluations:
if not is_negated_atom(atom):
node_from_atom[fact_from_evaluation(atom)] = Node(0, None)
queue = [
HeapElement(node.effort, atom)
for atom, node in node_from_atom.items()
]
while queue:
atom = heappop(queue).value
if atom not in unprocessed_from_atom:
continue
for result in unprocessed_from_atom[atom]:
remaining_from_stream[result] -= 1
if remaining_from_stream[result]:
continue
effort = result.get_effort(**effort_args)
total_effort = effort + EFFORT_OP(
node_from_atom[cond].effort
for cond in conditions_from_stream[result])
if max_effort <= total_effort:
continue
for new_atom in result.get_certified():
if (new_atom not in node_from_atom) or (
total_effort < node_from_atom[new_atom].effort):
node_from_atom[new_atom] = Node(total_effort, result)
heappush(queue, HeapElement(total_effort, new_atom))
del unprocessed_from_atom[atom]
del node_from_atom[NULL_COND]
return node_from_atom
def fd_from_evaluations(evaluations):
return [
fd_from_evaluation(e) for e in evaluations if not is_negated_atom(e)
]
