def run_on_one_instance(file):
print file
cmd = 'rm -rf *.log report.txt agent-*-plan.txt hyp-*-probs_over_time.csv *.res *.soln *.csv *.res.* *.pddl *.dat prob-*-PR'
os.system(cmd)
human_file = 'iros/test.tar.bz2'
cmd = 'python prob_PR.py -e ' + str(human_file) + '> stdout.txt'
os.system(cmd)
cmd = 'mkdir -p results && tar -jxvf results.tar.bz2 -C results/ > stdout.txt'
os.system(cmd)
hyps = []
instream = open('results/hyps.dat','r')
line = instream.readline().strip()
while line != '':
line = line.split(',')
hyps.append([ll[ll.find('(')+1:ll.find(')')].strip().replace(' ','_').upper() for ll in line])
line = instream.readline().strip()
instream.close()
instream = open('flag.txt','r')
curr = ast.literal_eval(instream.read().strip())
instream.close()
curr = [float(i)/sum(curr) for i in curr]
T = 25
num_kits = 5
medkits = ['MK1','MK2','MK3','MK4','MK5']
medkits = medkits[0:num_kits]
mk_groundings = ['AT_?_ROOM1','AT_?_ROOM2','AT_?_ROOM3','AT_?_ROOM4','AT_?_ROOM5','AT_?_HALL1','AT_?_HALL2','AT_?_HALL3','AT_?_HALL4','AT_?_HALL5']
globalVAR.resource_profiles_use = {}
globalVAR.resource_profiles_grnd = {}
for mk in medkits:
globalVAR.resource_profiles_use[mk,'IN_USE'] = numpy.zeros(T+1)
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
globalVAR.resource_profiles_grnd[tt] = numpy.zeros(T+1)
for idx in range(len(hyps)):
goal = hyps[idx]
#print '\nGoal : ', goal, ' :: probability = ', curr[idx]
gotodir = 'results/prob-' + str(idx) + '-PR/O/'
domainFile = gotodir + 'pr-domain.pddl'
problemFile = gotodir + 'pr-problem.pddl'
readFiles.read_input(domainFile, problemFile,'human')
#print '\nPlan: '
cmd = '~/Desktop/FAST-DOWNWARD/src/translate/translate.py ' + str(domainFile) + ' ' + str(problemFile) + '> stdout.txt'
os.system(cmd)
cmd = '~/Desktop/FAST-DOWNWARD/src/preprocess/preprocess < output.sas > stdout.txt'
os.system(cmd)
cmd = '~/Desktop/FAST-DOWNWARD/src/fast-downward.py --plan-file plan_' + str(idx) + '.dat output --search "astar(lmcut())" > stdout.txt'
os.system(cmd)
planFile = 'plan_' + str(idx) + '.dat'
instream = open(planFile, 'r')
current_plan = []
while True:
line = instream.readline().strip()
if 'cost' in line:
break
current_plan.append(line[line.find('(')+1:line.find(')')].strip().replace(' ','_').upper())
#for action in current_plan:
# print action
temp_profiles_use = {}
temp_profiles_grnd = {}
for mk in medkits:
temp_profiles_use[mk] = numpy.zeros(T+1)
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
temp_profiles_grnd[tt] = numpy.zeros(T+1)
temp_profiles_grnd[tt][0] = globalVAR.initState_human[globalVAR.listOfPredicates_human.index(tt)]*curr[idx]
flag = 0
for action in current_plan:
step = current_plan.index(action)
if 'PICK_UP' in action and mk in action:
flag = 1
if 'DROP_OFF' in action and mk in action:
flag = 0
temp_profiles_use[mk][step] = flag*curr[idx]
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
temp_profiles_grnd[tt][step+1] = temp_profiles_grnd[tt][step]
if flag == 1:
if 'MOVE' in action:
ext = ''
if 'OBS' in action:
ext = action.split('_')[-2]
else:
ext = action.split('_')[-1]
ext = 'AT_' + mk + '_' + ext
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
temp_profiles_grnd[tt][step+1] = 0
temp_profiles_grnd[ext][step+1] = flag*curr[idx]
for step in range(len(current_plan),T+1):
temp_profiles_use[mk][step] = temp_profiles_use[mk][step-1]
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
temp_profiles_grnd[tt][step] = temp_profiles_grnd[tt][step-1]
for step in range(T+1):
for mk in medkits:
globalVAR.resource_profiles_use[mk,'IN_USE'][step] += temp_profiles_use[mk][step]
for grnd in mk_groundings:
tt = grnd.replace('?',mk)
globalVAR.resource_profiles_grnd[tt][step] += temp_profiles_grnd[tt][step]
domainFile = 'iros/robot/mk'+str(num_kits)+'/domain.pddl'
problemFile = 'iros/robot/mk'+str(num_kits)+'/problem.pddl'
time = [10, 15, 20, 25]
for tt in time:
resource_plan.run_ip(domainFile, problemFile, tt)
def run_ip(domainFile, problemFile, T):
#print '\nReading domain and problem files...'
readFiles.read_input(domainFile, problemFile,'robot')
#print_actions()
#print_predicates()
start = time.time()
#print 'Building model...'
# parameters #
num_kits = 5
res = ['MK1','MK2','MK3','MK4','MK5']
res_grnd = ['AT_MK1_','AT_MK2_','AT_MK3_','AT_MK4_','AT_MK5_']
res = res[0:num_kits]
res_grnd = res_grnd[0:num_kits]
#print 'Building resource-action lists...'
res_act = build_resource_action_relations(res)
# Model #
m = Model("resourceplan")
# Optimization criterion #
m.modelSense = GRB.MINIMIZE
#print 'Adding variables...'
# define variables - y_a_t #
var = {}
var_grnd = {}
switchList = []
for vv in globalVAR.listOfPredicates_robot:
for t in range(T):
var[vv,t] = m.addVar(vtype=GRB.BINARY, name=str(vv) + '_%s' % (str(t)))
if True in [rg in vv for rg in res_grnd]:
var_grnd['res_'+vv,t] = m.addVar(vtype=GRB.BINARY, name='res_' + str(vv) + '_%s' % (str(t)))
if vv not in switchList:
switchList.append(vv)
# define variables - x_a_t #
act = {}
for aa in globalVAR.listOfActions_robot:
for t in range(1,T):
act[aa[0],t] = m.addVar(vtype=GRB.BINARY, name=str(aa[0]) + '_%s' % (str(t)))
# define variables - g_mk?_t #
res_var = {}
res_use = {}
for r in res:
for t in range(T):
res_var[r,t] = m.addVar(vtype=GRB.BINARY, name=str(r) + '_%s' % (str(t)))
res_use[r,t] = m.addVar(vtype=GRB.CONTINUOUS, name='use_' + str(r) + '_%s' % (str(t)))
# Update model with variables #
m.update()
#print 'Adding constraints...'
for r in res:
for t in range(T):
m.addConstr(res_use[r,t] <= globalVAR.resource_profiles_use[r,'IN_USE'][t])
# define constraints - initial state #
for vv in globalVAR.listOfPredicates_robot:
if True not in [pp in vv for pp in res_grnd]:
m.addConstr(var[vv,0] == globalVAR.initState_robot[globalVAR.listOfPredicates_robot.index(vv)])
else:
m.addConstr(var[vv,0] == 0)
for r in res:
m.addConstr(res_var[r,0] == 0)
# define constraints - goal state #
for vv in globalVAR.listOfPredicates_robot:
if globalVAR.goalState_robot[globalVAR.listOfPredicates_robot.index(vv)] != -1:
m.addConstr(var[vv,T-1] == globalVAR.goalState_robot[globalVAR.listOfPredicates_robot.index(vv)])
# define constraints - preconditions #
for t in range(1,T):
for aa in globalVAR.listOfActions_robot:
for precondition in aa[1]:
if True not in [pp in precondition for pp in res_grnd]:
m.addConstr(act[aa[0],t] <= var[precondition,t-1])
else:
m.addConstr(var_grnd['res_'+precondition,t-1] == act[aa[0],t])
#m.addConstr(var[precondition,T-1] >= var_grnd['res_'+precondition,t-1])
for switch in switchList:
m.addConstr(var_grnd['res_'+switch,T-1] == 0)
# define constraints - add effects #
for t in range(1,T):
for vv in globalVAR.listOfPredicates_robot:
tempList1 = []
tempList2 = []
for aa in globalVAR.listOfActions_robot:
if vv in aa[2]:
tempList1.append(aa[0])
if vv in aa[3]:
tempList2.append(aa[0])
m.addConstr(var[vv,t] == quicksum(act[aa,t] for aa in tempList1) + (1-quicksum(act[aa,t] for aa in tempList1)-quicksum(act[aa,t] for aa in tempList2))*var[vv,t-1])
m.addConstr(var[vv,t] <= quicksum(act[aa,t] for aa in tempList1) + (1-quicksum(act[aa,t] for aa in tempList1))*var[vv,t-1])
#m.addConstr(var[vv,t] <= 1-quicksum(act[aa,t] for aa in tempList2))
# define constraints - no concurrency #
for t in range(1,T):
m.addConstr(quicksum(act[aa[0],t] for aa in globalVAR.listOfActions_robot) == 1)
# define constraints - no repetitions #
for r in res:
m.addConstr(quicksum(quicksum(act[aa,t] for aa in res_act[r][0]) for t in range(1,T)) <= 1)
# define constraints - resource profiles #
m.update()
for t in range(1,T):
for r in res:
m.addConstr(res_var[r,t] == quicksum(act[aa,t] for aa in res_act[r][0]) + (1-quicksum(act[aa,t] for aa in res_act[r][0]) - quicksum(act[aa,t] for aa in res_act[r][1]))*res_var[r,t-1])
#m.addConstr(res_var[r,t] <= quicksum(act[aa,t] for aa in res_act[r][0]))
#for t in range(1,T):
#m.addConstr(quicksum(var[vv,t] for vv in switchList) == 1)
for t in range(T):
for rg in switchList:
m.addConstr(globalVAR.resource_profiles_grnd[rg][t]*var_grnd['res_'+rg,t] + (1-var_grnd['res_'+rg,t]) >= 0.001)
# set optimization objective function #
m.setObjective(objective_function(act, var, res, res_use, res_var, var_grnd, switchList, T))
# optimize #
#print "Optimizing..."
m.params.OutputFlag = 0
m.optimize()
end = time.time()
# print solution #
status = m.status
if status == GRB.OPTIMAL:
ret = print_plan(m, res, T)
print 'Time: ', (end-start), 'Cost: ', ret[0], 'Conflict: ', ret[1], 'Success', ret[2], 'T = ', T
#print '\nTime Taken:', (end - start), ' sec'
#print('Obj: %g' % m.ObjVal)
else:
print 'Optimization was stopped with status %d' %status
