def setup(self, plan_name): """ Create step typed element DI, with effect edges to each condition of start_set Create step typed element DG, with precondition edges to each condition of end_set Add ordering from DI to DG """ s_init = copy.deepcopy(self.GL[-2]) s_init.replaceInternals() s_goal = copy.deepcopy(self.GL[-1]) s_goal.replaceInternals() s_init_plan = PlanElementGraph(name=plan_name, Elements=self.objects|s_init.elements|s_goal.elements, Edges=s_init.edges|s_goal.edges) s_init_plan.initial_dummy_step = s_init.root s_init_plan.final_dummy_step = s_goal.root s_init_plan.OrderingGraph.addOrdering(s_init.root, s_goal.root) #Add initial Open precondition flaws for dummy step #init_flaws = (Flaw((s_goal.root, prec), 'opf') for prec in s_goal.Preconditions) #for flaw in init_flaws: for prec in s_goal.Preconditions: s_init_plan.flaws.insert(self.GL, s_init_plan, Flaw((s_goal.root, prec), 'opf')) return s_init_plan
def multiGoalSetup(self, SP):
#s_init is in the back for a multi-goal setup
init = copy.deepcopy(self.disc_GL[-1])
init.replaceInternals()
BPlans = []
for GA in self.disc_GL.Goal_Actions:
s_goal = copy.deepcopy(GA)
s_init = copy.deepcopy(init)
DPlan = PlanElementGraph(name='disc',
Elements=s_init.elements
| s_goal.elements,
Edges=s_init.edges | s_goal.edges)
DPlan.initial_dummy_step = s_init.root
DPlan.final_dummy_step = s_goal.root
DPlan.OrderingGraph.addOrdering(s_init.root, s_goal.root)
init_flaws = (Flaw((s_goal.root, prec), 'opf')
for prec in s_goal.preconditions)
for flaw in init_flaws:
DPlan.flaws.insert(self.disc_GL, DPlan, flaw)
Story = SP.deepcopy()
New_Stories = Unify(Story, s_goal.ground_subplan, self.story_GL)
for NS in New_Stories:
BPlans.append(BiPlan(NS, DPlan))
return BPlans
def domainToOperatorGraphs(domain): opGraphs = set() dopGraphs = set() for action in domain.actions: op = Operator(name=action.name, num_args=len(action.parameters)) op_graph = Action(name=action.name, root_element=op) evalActionParams(action.parameters, op_graph) if action.precond is not None: getFormulaGraph(action.precond.formula, op_graph, parent=op, relationship='precond-of', elements=op_graph.elements, edges=op_graph.edges) if action.effect is not None: getFormulaGraph(action.effect.formula, op_graph, parent=op, relationship='effect-of', elements=op_graph.elements, edges=op_graph.edges) if action.decomp is not None: # henceforth, action.decomp is tuple (sub-params, decomp) decomp_graph = PlanElementGraph(name=action.name, type_graph='decomp') getDecompGraph(action.decomp.formula, decomp_graph, action.parameters + action.decomp.sub_params) op_graph.subplan = decomp_graph # This searches for params that are listed as params and sub-params, may not be needed # opelms = list(op_graph.elements) # dpelms = list(decomp_graph.elements) # for step_elm in opelms: # for d_elm in dpelms: # if not isinstance(d_elm, Argument): # continue # if d_elm.arg_name == step_elm.arg_name: # op_graph.assign(step_elm, d_elm) dopGraphs.add(op_graph) else: opGraphs.add(op_graph) return opGraphs, dopGraphs
def Plannify(RQ, GL):
#An ActionLib for steps in RQ - ActionLib is a container w/ all of its possible instances as ground steps
print('... Processing {}'.format(RQ.name))
print('...ActionLibs')
Libs = [
ActionLib(i, RS, GL) for i, RS in enumerate(
[Action.subgraph(RQ, step) for step in RQ.Steps])
]
#A World is a combination of one ground-instance from each step
Worlds = productByPosition(Libs)
print('...Planets')
#A Planet is a plan s.t. all steps are "arg_name consistent", but a step may not be equiv to some ground step
Planets = [
PlanElementGraph.Actions_2_Plan(W) for W in Worlds
if isArgNameConsistent(W)
]
print('...Linkify')
#Linkify installs orderings and causal links from RQ/decomp to Planets, rmvs Planets which cannot support links
has_links = Linkify(Planets, RQ, GL)
print('...Groundify')
#Groundify is the process of replacing partial steps with its ground step, and removing inconsistent planets
Plans = Groundify(Planets, GL, has_links)
print('...returning consistent plans')
return [Plan for Plan in Plans if Plan.isInternallyConsistent()]
def problemToGraphs(problem):
"""
Returns a dictionary:
Keys: 'arg', 'init', 'goal'
Values: arg dictionary, (elements, edges), (elements, edges)
"""
if problem.goalAction is not None:
action = problem.goalAction
gop = Operator(name=action.name, num_args=len(action.parameters))
GoalAction = Action(name=action.name, root_element=gop)
evalActionParams(action.parameters, GoalAction)
getFormulaGraph(action.precond.formula,
GoalAction,
parent=gop,
relationship='precond-of',
elements=GoalAction.elements,
edges=GoalAction.edges)
decomp_graph = PlanElementGraph(name=action.name, type_graph='decomp')
getDecompGraph(action.decomp.formula, decomp_graph, action.parameters)
GoalAction.subgraphs.add(decomp_graph)
goal_graph = GoalAction
init_op = Operator(name='dummy_init', stepnumber=0, num_args=0)
init_graph = Action(name='dummy_init', root_element=init_op)
Args = dict()
else:
Args = {
object.name: Argument(name=object.name, typ=object.typeName)
for object in problem.objects
if not object.typeName.lower() in {'character', 'actor'}
}
Args.update({
object.name: Actor(name=object.name)
for object in problem.objects
if object.typeName.lower() in {'character', 'actor'}
})
goal_elements, goal_edges = getGoalSet(problem.goal.formula, Args)
goal_op = Operator(name='dummy_goal', stepnumber=1, num_args=0)
goal_graph = Action(name='dummy_goal', root_element=goal_op)
goal_graph.elements.update(goal_elements)
goal_graph.edges.update(goal_edges)
goal_graph.edges.update({
Edge(goal_op, goal_lit, 'precond-of')
for goal_lit in goal_elements if type(goal_lit) is Literal
})
init_op = Operator(name='dummy_init', stepnumber=0, num_args=0)
init_graph = Action(name='dummy_init', root_element=init_op)
for condition in problem.init.predicates:
lit = Literal(name=condition.name,
num_args=len(condition.parameters),
truth=True)
init_graph.elements.add(lit)
init_graph.edges.add(Edge(init_op, lit, 'effect-of'))
for i, p in enumerate(condition.parameters):
init_graph.edges.add(Edge(lit, Args[p], ARGLABELS[i]))
return (Args, init_graph, goal_graph)
def domainToOperatorGraphs(domain):
opGraphs = set()
for action in domain.actions:
op = Operator(name=action.name, num_args=len(action.parameters))
op_graph = Action(name=action.name, root_element=op)
evalActionParams(action.parameters, op_graph)
if action.precond is not None:
getFormulaGraph(action.precond.formula,
op_graph,
parent=op,
relationship='precond-of',
elements=op_graph.elements,
edges=op_graph.edges)
if action.effect is not None:
getFormulaGraph(action.effect.formula,
op_graph,
parent=op,
relationship='effect-of',
elements=op_graph.elements,
edges=op_graph.edges)
if hasattr(action, 'decomp') and action.decomp is not None:
decomp_graph = PlanElementGraph(name=action.name,
type_graph='decomp')
getDecompGraph(action.decomp.formula, decomp_graph,
action.parameters)
op_graph.subgraphs.add(decomp_graph)
for step_elm in op_graph.elements:
for d_elm in decomp_graph.elements:
if not isinstance(d_elm, Argument):
continue
if d_elm.arg_name == step_elm.arg_name:
op_graph.assign(step_elm, d_elm)
opGraphs.add(op_graph)
return opGraphs