def _create_model(self, city_ids, map_points):
depot_id = city_ids[0]
city_num = len(city_ids)
## prepare the index for decision variables
# index of network flow
cities = tuple(city_ids)
# connecting arcs of the cities
cityArcs = [(i, j) for i in cities for j in cities if i != j]
## parameters model (dictionary)
# 1. distance map
distances_map = self.calculate_distances(city_ids, map_points)
## create model
m = Model('TSP')
## create decision variables
# 1. choice of arcs between cities
x = m.addVars(cityArcs, vtype=GRB.BINARY, name='route')
m._x = x
m._cities = cities
m._cityArcs = cityArcs
## create objective: minimum route distance
m.setObjective(
quicksum([x[i, j] * distances_map[(i, j)] for (i, j) in cityArcs]),
GRB.MINIMIZE) # TOTRY
## create constraints
# 1. Network flow
m.addConstrs((quicksum([x[i, j] for j in cities if i != j]) == 1
for i in cities), 'Network flow1')
m.addConstrs((quicksum([x[i, j] for i in cities if i != j]) == 1
for j in cities), 'Network flow2')
for (i, j) in cityArcs:
if (i, j) in init_solution:
x[i, j].start = 1
return m, x
def __init__(self, distances, taxis, requests, timeout=None):
self.distances = distances
self.taxis = taxis
self.requests = requests
self.timeout = timeout
model = Model('static_dispatching')
model.params.OutputFlag = 0
model.params.UpdateMode = 1
model.Params.PreCrush = 1
model.Params.LazyConstraints = 1
T = 1000000
n_taxis = len(taxis)
n_requests = len(requests)
n = n_taxis + n_requests
t = distances
x = []
for i in range(n):
u = []
for j in range(n):
v = model.addVar(lb=0.0, ub=1.0, vtype=GRB.BINARY)
u.append(v)
x.append(u)
pick0 = []
for i in range(n_requests):
u = model.addVar(lb=0.0, ub=GRB.INFINITY, vtype=GRB.CONTINUOUS)
pick0.append(u)
# constraint (2)
for v in range(n):
model.addConstr(quicksum([x[u][v] for u in range(n)]), GRB.EQUAL,
1)
# constraint (3)
for u in range(n):
model.addConstr(quicksum([x[u][v] for v in range(n)]), GRB.EQUAL,
1)
# constraint (5)
for i in range(n_requests):
model.addConstr(
pick0[i] -
quicksum([(taxis[k][0] + t[taxis[k][1]][requests[i][1]]) *
x[k][n_taxis + i]
for k in range(n_taxis)]), GRB.GREATER_EQUAL, 0)
# constraint (6)
for i in range(n_requests):
for j in range(n_requests):
model.addConstr(
pick0[j] - pick0[i] - t[requests[i][1]][requests[i][2]] -
t[requests[i][2]][requests[j][1]] + T *
(1 - x[n_taxis + i][n_taxis + j]), GRB.GREATER_EQUAL, 0)
# constraint (7)
for i in range(n_requests):
model.addConstr(pick0[i], GRB.GREATER_EQUAL, requests[i][0])
objective = quicksum(pick0[i] - requests[i][0]
for i in range(n_requests))
model.setObjective(objective, GRB.MINIMIZE)
#model._cutfinder = Cut_Finder(n_vertices, edges)
model._x = x
model._pick0 = pick0
#model._k = k
#model._relobj = None
#model._impcounter = 0
#model._single_cut = single_cut
# runtime information
#model._root_cuttime = 0
#model._tree_cuttime = 0
self.model = model
