def add_stream_costs(node_from_atom, instantiated, unit_efforts, effort_weight): # TODO: instantiate axioms with negative on effects for blocking # TODO: fluent streams using conditional effects. Special fluent predicate for inputs to constraint # This strategy will only work for relaxed to ensure that the current state is applied for instance in instantiated.actions: # TODO: prune stream actions here? # Ignores conditional effect costs facts = [] for precondition in get_literals(instance.action.precondition): if precondition.negated: continue args = [instance.var_mapping.get(arg, arg) for arg in precondition.args] literal = precondition.__class__(precondition.predicate, args) fact = fact_from_fd(literal) if fact in node_from_atom: facts.append(fact) #effort = COMBINE_OP([0] + [node_from_atom[fact].effort for fact in facts]) stream_plan = [] extract_stream_plan(node_from_atom, facts, stream_plan) if unit_efforts: effort = len(stream_plan) else: effort = scale_cost(sum([0] + [r.instance.get_effort() for r in stream_plan])) if effort_weight is not None: instance.cost += effort_weight*effort # TODO: bug! The FD instantiator prunes the result.external.stream_fact for result in stream_plan: # TODO: need to make multiple versions if several ways of achieving the action if is_optimizer_result(result): fact = substitute_expression(result.external.stream_fact, result.get_mapping()) atom = fd_from_fact(fact) instantiated.atoms.add(atom) effect = (tuple(), atom) instance.add_effects.append(effect)
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)