def make_plan(domain,
problem,
planners=['optic-clp'],
agents=[],
temporal_actions=[],
rank=False,
verbose=False):
import planner
import dot_plan
import dot_ma_plan
# make a policy given domain and problem
policy = planner.Planner(domain=domain,
problem=problem,
planners=planners,
rank=rank,
verbose=verbose)
# transform the produced policy into a contingency plan and print it
plan = policy.plan()
policy.print_plan(plan=plan)
#############################
# get possible concurrent and joint executions
single_executions, joint_executions = concurrent_executions(
policy, plan, agents)
if verbose:
print(color.fg_yellow('----------------------------------'))
print(color.fg_yellow('-- possible concurrent executions'))
print(color.fg_yellow('----------------------------------'))
for i, single_execution in enumerate(single_executions):
print(color.fg_yellow('-- execution_{}'.format(str(i))))
for level, (actions, outcomes) in sorted(single_execution.items()):
# for level, (actions, outcomes) in sorted(merge_dict(single_execution,joint_executions).items()):
print('{} : {} {}'.format(str(level),
' '.join(map(str,
actions)), outcomes))
print(color.fg_yellow('-- joint executions'))
for level, (actions, outcomes) in joint_executions.items():
print('{} : {} {}'.format(str(level), ' '.join(map(str, actions)),
outcomes))
#############################
# refine and separate the concurrent executions into concurrent clusters
main_list = concurrent_subplans(policy, plan, agents)
if verbose:
print(color.fg_yellow('\n----------------------------------'))
print(color.fg_yellow('-- actual multi-agent plan'))
print(color.fg_yellow('----------------------------------'))
for i, (key, subplans) in enumerate(main_list.items()):
print(
color.fg_yellow(
'---------------------------------- block_{}'.format(
str(i))))
for j, subplan in enumerate(subplans):
if (len(subplans)) > 1:
print(color.fg_beige('-- subplan_{}'.format(str(j))))
for k, (actions, outcomes) in subplan.items():
print('{} -- {} {}'.format(k, ' '.join(map(str, actions)),
outcomes))
#############################
# convert the plan inti a concurrent plan in json files
plan_json_file, actions_json_file = json_ma_plan(policy, agents,
temporal_actions)
print(color.fg_yellow('-- plan_json_file:') + plan_json_file)
print(color.fg_yellow('-- actions_json_file:') + actions_json_file)
print(
color.fg_yellow('-- graphical plan_json_file:') + plan_json_file +
'.dot')
os.system('lua lua/json_multiagent_plan.lua %s &' % plan_json_file)
if verbose: os.system('xdot %s.dot &' % plan_json_file)
# generate a graph of the policy as a dot file in graphviz
dot_file = dot_plan.gen_dot_plan(plan=plan,
domain_file=domain,
problem_file=problem)
print(color.fg_yellow('-- plan in dot file: ') + dot_file)
# transform the plan into a parallel plan
dot_file, tred_dot_file = dot_ma_plan.parallel_plan(policy,
verbose=verbose)
print(color.fg_yellow('-- precedence graph: ') + dot_file)
print(color.fg_yellow('-- transitive reduction: ') + tred_dot_file)
if verbose: os.system('xdot %s &' % tred_dot_file)
# print out resulting info
print('\nPlanning domain: %s' % policy.domain_file)
print('Planning problem: %s' % policy.problem_file)
print('Arguments: %s' % ' '.join(sys.argv[3:]))
print('Policy length: %i' % len(policy.policy))
print('Plan length: %i' % (len(plan) - 1))
print('Compilation time: %.3f s' % policy.compilation_time)
print('Planning time: %.3f s' % policy.planning_time)
print('Planning iterations (all-outcome): %i' %
policy.alloutcome_planning_call)
print('Total number of replannings (single-outcome): %i' %
policy.singleoutcome_planning_call)
print('Total number of unsolvable states: %i' %
len(policy.unsolvable_states))
return (policy, plan, plan_json_file, actions_json_file)
# convert the plan inti a concurrent plan in json files
plan_json_file, actions_json_file = json_ma_plan(policy,
args.agents,
full=True)
print(color.fg_yellow('-- plan_json_file:') + plan_json_file)
print(color.fg_yellow('-- actions_json_file:') + actions_json_file)
os.system('cd lua && lua json_multiagent_plan.lua ../%s &' %
plan_json_file)
os.system('xdot %s.dot &' % plan_json_file)
print('')
# generate a graph of the policy as a dot file in graphviz
if args.dot:
dot_file = dot_plan.gen_dot_plan(plan=plan,
domain_file=args.domain,
problem_file=args.problem)
print(color.fg_yellow('-- dot file: ') + dot_file + '\n')
os.system('xdot %s &' % dot_file)
# transform the plan into a parallel plan
import dot_ma_plan
dot_file, tred_dot_file = dot_ma_plan.parallel_plan(
policy, verbose=args.verbose)
print(color.fg_yellow('-- graphviz file: ') + dot_file)
print(color.fg_yellow('-- transitive reduction: ') + tred_dot_file)
# print out resulting info
if args.problem is not None:
print('\nPlanning domain: %s' % policy.domain_file)
print('Planning problem: %s' % policy.problem_file)
def main():
## parse arguments
parser = parse()
args = parser.parse_args()
if args.domain == None:
parser.print_help()
sys.exit()
## make a policy given domain and problem
policy = planner.Planner(args.domain, args.problem, args.planners,
args.safe_planner, args.rank, args.all_outcome,
args.verbose)
## transform the produced policy into a contingency plan
plan = policy.plan()
## print out the plan in a readable form
policy.print_plan(del_effect_inc=True, det_effect_inc=False)
## print out sub-paths in the plan
if args.path:
paths = policy.get_paths(plan)
policy.print_paths(paths=paths, del_effect_inc=True)
# for path in paths:
# policy.print_plan(plan=path, del_effect_inc=True)
## generate graphs of sub-paths too
if args.dot:
for i, path in enumerate(paths):
dot_file = dot_plan.gen_dot_plan(plan=path)
print(
color.fg_yellow('-- path{} dot file: ').format(str(i +
1)) +
dot_file)
# os.system('xdot %s &' % dot_file)
dot_file = dot_plan.gen_dot_plan(plan=paths[0])
# os.system('xdot %s &' % dot_file)
print('')
## generate a graph of the policy as a dot file in graphviz
if args.dot:
plan = policy.plan(tree=True)
dot_file = dot_plan.gen_dot_plan(plan=plan,
del_effect=True,
domain_file=args.domain,
problem_file=args.problem)
print(color.fg_yellow('-- dot file: ') + dot_file + '\n')
# os.system('xdot %s &' % dot_file)
# os.system('dot -T pdf %s > %s.pdf &' % (dot_file, dot_file))
# os.system('evince %s.pdf &' % dot_file)
## transform the policy into a json file
if args.json:
import json_ma_plan
import dot_ma_plan
json_output = json_ma_plan.json_ma_plan(policy, verbose=args.verbose)
if json_output is not None:
plan_json_file, actions_json_file = json_output
print(
color.fg_yellow('-- plan_json_file:') + plan_json_file +
color.fg_red(' [EXPERIMENTAL!]'))
print(
color.fg_yellow('-- actions_json_file:') + actions_json_file +
color.fg_red(' [EXPERIMENTAL!]'))
os.system('cd lua && lua json_multiagent_plan.lua ../%s &' %
plan_json_file)
print(
color.fg_yellow('-- plan_json_dot_file:') +
('%s.dot' % plan_json_file) + color.fg_red(' [EXPERIMENTAL!]'))
# transform the plan into a parallel plan
dot_file, tred_dot_file = dot_ma_plan.parallel_plan(
policy, verbose=args.verbose)
print(color.fg_yellow('-- graphviz file: ') + dot_file)
print(color.fg_yellow('-- transitive reduction: ') + tred_dot_file)
# os.system('xdot %s.dot &' % plan_json_file)
## transform the policy into a json file
if args.json:
import json_plan
plan = policy.plan(tree=False)
json_file, plan_json = json_plan.json_plan(policy)
print(
color.fg_yellow('\n-- json file: ') + json_file +
color.fg_red(' [EXPERIMENTAL!]'))
print(
color.fg_yellow('-- try: ') + 'lua json_plan.lua ' + json_file +
color.fg_red(' [EXPERIMENTAL!]\n'))
if args.store:
stat_file = policy.log_performance(plan)
print(color.fg_yellow('-- planner performance: ') + stat_file)
# print out resulting info
if args.problem is not None:
print('\nPlanning domain: %s' % policy.domain_file)
print('Planning problem: %s' % policy.problem_file)
print('Arguments: %s' % ' '.join(sys.argv[3:]))
else:
print('Planning problem: %s' % policy.domain_file)
print('Arguments: %s' % ' '.join(sys.argv[2:]))
print('Policy length: %i' % len(policy.policy))
print('Plan length: %i' % (len(plan) - 1))
print('Compilation time: %.3f s' % policy.compilation_time)
print('Planning time: %.3f s' % policy.planning_time)
print('Planning iterations (all-outcome): %i' %
policy.alloutcome_planning_call)
print('Total number of replannings (single-outcome): %i' %
policy.singleoutcome_planning_call)
print('Total number of unsolvable states: %i' %
len(policy.unsolvable_states))