def add_optimizer_effects(instantiated, node_from_atom):
# TODO: instantiate axioms with negative on effects for blocking
# TODO: fluent streams using conditional effects. Special fluent predicate for inputs to constraint
# TODO: bug! The FD instantiator prunes the result.external.stream_fact
for instance in instantiated.actions:
# TODO: need to handle case where a negative preconditions is used in an optimizer
for condition, effect in (instance.add_effects + instance.del_effects):
for literal in condition:
fact = fact_from_fd(literal)
if (fact in node_from_atom) and (node_from_atom[fact].result
is not None):
raise NotImplementedError(literal)
facts = get_instance_facts(instance, node_from_atom)
stream_plan = []
extract_stream_plan(node_from_atom, facts, stream_plan)
# TODO: can detect if some of these are simultaneous and add them as preconditions
for result in stream_plan:
#if isinstance(result.external, ComponentStream):
if True: # TODO: integrate sampler and optimizer treatments
# TODO: need to make multiple versions if several ways of achieving the action
atom = fd_from_fact(result.stream_fact)
instantiated.atoms.add(atom)
effect = (tuple(), atom)
instance.add_effects.append(effect)
instance.effect_mappings.append(effect + (None, None))
def add_stream_efforts(node_from_atom, instantiated, effort_weight, **kwargs):
if effort_weight is None:
return
# TODO: make effort just a multiplier (or relative) to avoid worrying about the scale
# TODO: regularize & normalize across the problem?
#efforts = []
for instance in instantiated.actions:
# TODO: prune stream actions here?
# TODO: round each effort individually to penalize multiple streams
facts = get_instance_facts(instance, node_from_atom)
#effort = COMBINE_OP([0] + [node_from_atom[fact].effort for fact in facts])
stream_plan = []
extract_stream_plan(node_from_atom, facts, stream_plan)
effort = compute_plan_effort(stream_plan, **kwargs)
instance.cost += scale_cost(effort_weight * effort)