def apply(self, manager: pywrapcp.RoutingModel, routing: pywrapcp.RoutingModel, data_model: DataModel):
def distance_callback(from_index, to_index):
"""Returns the distance between the two nodes."""
# Convert from routing variable Index to distance matrix NodeIndex.
from_node = manager.IndexToNode(from_index)
to_node = manager.IndexToNode(to_index)
return data_model.distance_matrix[from_node][to_node]
transit_callback_index = routing.RegisterTransitCallback(distance_callback)
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
dimension_name = 'Distance'
routing.AddDimension(
transit_callback_index,
0, # no slack
3000, # vehicle maximum travel distance
True, # start cumul to zero
dimension_name)
distance_dimension = routing.GetDimensionOrDie(dimension_name)
distance_dimension.SetGlobalSpanCostCoefficient(100)
for i in range(data_model.number_of_engineers):
routing.AddVariableMinimizedByFinalizer(
distance_dimension.CumulVar(routing.Start(i)))
routing.AddVariableMinimizedByFinalizer(
distance_dimension.CumulVar(routing.End(i)))
return routing
def main() -> None:
"""
Entry point of the program.
"""
# Parse command line arguments
args = parse_args()
# Instantiate the data problem
data = load_data_model(args.path)
# Create the Routing Index Manager and Routing Model
manager = RoutingIndexManager(data["num_locations"], data["num_vehicles"],
data["depot"])
routing = RoutingModel(manager)
# Define weights of edges
weight_callback_index = routing.RegisterTransitCallback(
create_weight_callback(manager, data))
routing.SetArcCostEvaluatorOfAllVehicles(weight_callback_index)
# Add capacity constraints
demand_callback = create_demand_callback(manager, data)
demand_callback_index = routing.RegisterUnaryTransitCallback(
demand_callback)
add_capacity_constraints(routing, manager, data, demand_callback_index)
# Add time window constraints
time_callback_index = routing.RegisterTransitCallback(
create_time_callback(manager, data))
add_time_window_constraints(routing, manager, data, time_callback_index)
# Set first solution heuristic (cheapest addition)
search_params = DefaultRoutingSearchParameters()
search_params.first_solution_strategy = FirstSolutionStrategy.PATH_CHEAPEST_ARC
if args.gls:
search_params.local_search_metaheuristic = (
LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
# NOTE: Since Guided Local Search could take a very long time, we set a
# reasonable time limit
search_params.time_limit.seconds = 30
if args.verbose:
search_params.log_search = True
# Solve the problem
assignment = routing.SolveWithParameters(search_params)
if not assignment:
print("No solution found.")
return
# Print the solution
print_solution(data, routing, manager, assignment)
# Export network and route graphs
if args.export_network_graph:
draw_network_graph(args.export_network_graph, data)
if args.export_route_graph:
draw_route_graph(args.export_route_graph, data, routing, manager,
assignment)
def main():
numLocations = 8
depotIndex = 0
numVehicles = 3
vehicleCapacity = 3
times = [[0, 957.7, 748.5, 570.8, 706.7, 574.2, 893.2, 187],
[975.1, 0, 436.6, 894.6, 293, 446.4, 760.2, 901.2],
[814.6, 399.6, 0, 458, 352.5, 231.5, 876.8, 675.8],
[526.8, 841.3, 441.7, 0, 785.8, 598.5, 1266.5, 457.8],
[733.3, 328.4, 351.6, 748.7, 0, 231.8, 625, 659.4],
[713.7, 360.9, 174.3, 577.1, 270.3, 0, 845.2, 639.8],
[917.6, 919.7, 1000.8, 1357.9, 733.1, 931, 0, 996.4],
[246.7, 901.6, 626.4, 383.8, 673.9, 540.7, 986.4, 0]]
def timeCallback(s, t):
return times[s][t]
#demands = [0, 0, 1, 1, 3, 0, 0, 1]
demands = [0, 1, 1, 1, 1, 1, 1, 1]
def demandsCallback(s, _):
return demands[s]
pickupDeliveries = [
(6, 4), (5, 4)
] #[ ( 6, 4 ), ( 5, 4 ), ( 5, 3 ), ( 1, 2 ), ( 5, 2 ), ( 6, 4 ), ( 5, 7 ) ];
model = RoutingModel(numLocations, numVehicles, depotIndex)
model.SetArcCostEvaluatorOfAllVehicles(timeCallback)
model.AddDimension(timeCallback, 28800, 28800, True, 'Time')
timeDimension = model.GetDimensionOrDie('Time')
for i in range(numLocations):
timeDimension.CumulVar(i).SetRange(0, 28800)
model.AddDimension(demandsCallback, 0, vehicleCapacity, True, 'Capacity')
capacityDimension = model.GetDimensionOrDie('Capacity')
solver = model.solver()
for pickup, delivery in pickupDeliveries:
pickupIndex = model.NodeToIndex(pickup)
deliveryIndex = model.NodeToIndex(delivery)
solver.AddConstraint(
model.VehicleVar(pickupIndex) == model.VehicleVar(deliveryIndex))
solver.AddConstraint(
timeDimension.CumulVar(pickupIndex) <= timeDimension.CumulVar(
deliveryIndex))
model.AddPickupAndDelivery(pickup, delivery)
assignment = model.Solve()
if not assignment:
sys.exit('Error: No Assignment')
printAssignment(assignment, model)
def solve(self, indices_to_visit: List[int] = None) -> Dict[str, Any]:
"""Finds the optimal order of facilities to minimize distance.
Parameters
----------
indices_to_visit : List[int]
The list of indices corresponding to the desired facilities to visit
Returns
-------
Dict[str, Any]
Soltution dictionary with keys:
- 'objective', set to objective value (minified distance)
- 'order', instructions for the order of facilities to visit
"""
if indices_to_visit is None:
indices_to_visit = list(range(len(self.matrix)))
# make sure home location is in the listed, and that the list is sorted
if self.home_index not in indices_to_visit:
indices_to_visit.append(self.home_index)
indices_to_visit.sort()
data = self._create_data_model(indices_to_visit)
# create routing index manager
manager = RoutingIndexManager(len(data['distance_matrix']),
data['num_vehicles'], data['home'])
# create routing model
routing = RoutingModel(manager)
def distance_callback(from_index, to_index):
# returns distance between two nodes
from_node = manager.IndexToNode(from_index)
to_node = manager.IndexToNode(to_index)
dist = data['distance_matrix'][from_node][to_node]
return dist
transit_callback_index = routing.RegisterTransitCallback(
distance_callback)
# define cost of each arc
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
# set first solution heuristic
search_params = pywrapcp.DefaultRoutingSearchParameters()
search_params.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
# solve problem
assignment = routing.SolveWithParameters(search_params)
return self._extract_solution(manager, routing, assignment,
indices_to_visit)
def _set_objective_function(problem: Problem, manager: RoutingIndexManager,
solver: RoutingModel):
"""Method to set the objective function of the Optimization Model"""
def _time_callback(from_index: int, to_index: int):
"""Callback to obtain the complete time between Stops"""
origin = manager.IndexToNode(from_index)
destination = manager.IndexToNode(to_index)
travelling_time = problem.estimations[(origin, destination)]
service_time = problem.stops[destination].service_time
return travelling_time + service_time
callback_index = solver.RegisterTransitCallback(_time_callback)
solver.SetArcCostEvaluatorOfAllVehicles(callback_index)
logging.info('Set the objective function to the OptimizationModel.')
def main():
"""
Entry point of the program.
"""
# Parse command line arguments
args = parse_args()
#Crafted data :
coordinates = [[0.848307, 0.32357132], [0.53917086, 0.862489],
[0.28499496, 0.7470896], [0.66891015, 0.07388902],
[0.6514969, 0.4077109], [0.782356, 0.28167558],
[0.2601446, 0.9196638], [0.3402847, 0.62080956],
[0.3920853, 0.8653455], [0.79114413, 0.09456837],
[0.11343169, 0.73570406]]
Distance_matrix = list()
for j in range(len(coordinates)):
l = list()
for i in range(len(coordinates)):
l.append(distance(coordinates[j], coordinates[i]))
Distance_matrix.append(l)
data = dict()
data['weights'] = Distance_matrix
data['service_times'] = [0, 1, 0.5, 1, 1, 0.5, 2, 2, 2, 0.5, 2]
data['demands'] = [
0, 0.25, 0.2, 0.1, 0.2, 0.35, 0.15, 0.3, 0.15, 0.15, 0.3
]
data['time_windows'] = [[0, 9], [0, 5], [5, 9], [0, 9], [0, 9], [0, 9],
[0, 5], [5, 9], [5, 9], [0, 5], [0, 9]]
data['vehicle_capacities'] = [1, 1, 1]
data['depot'] = 0
data['num_locations'] = 11
data['num_vehicles'] = 3
# Instantiate the data problem
#data = load_data_model(args.path)
# Create the Routing Index Manager and Routing Model
manager = RoutingIndexManager(data['num_locations'], data['num_vehicles'],
data['depot'])
routing = RoutingModel(manager)
# Define weight of each edge
weight_callback_index = routing.RegisterTransitCallback(
create_weight_callback(manager, data))
routing.SetArcCostEvaluatorOfAllVehicles(weight_callback_index)
# Add capacity constraints
demand_callback = create_demand_callback(manager, data)
demand_callback_index = routing.RegisterUnaryTransitCallback(
demand_callback)
add_capacity_constraints(routing, manager, data, demand_callback_index)
# Add time window constraints
time_callback_index = routing.RegisterTransitCallback(
create_time_callback(manager, data))
add_time_window_constraints(routing, manager, data, time_callback_index)
# Set first solution heuristic (cheapest addition)
search_params = DefaultRoutingSearchParameters()
# pylint: disable=no-member
search_params.first_solution_strategy = FirstSolutionStrategy.PATH_CHEAPEST_ARC
if args.gls:
# pylint: disable=no-member
search_params.local_search_metaheuristic = LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
# NOTE: Since Guided Local Search could take a very long time, we set a reasonable time
# limit
search_params.time_limit.seconds = 30
if args.verbose:
search_params.log_search = True
# Solve the problem
assignment = routing.SolveWithParameters(search_params)
if not assignment:
print('No solution found.')
return
# Print the solution
print_solution(Distance_matrix, data, routing, manager, assignment)
# Draw network and route graphs
"""if args.graph:
hoge = OrtoolsJson(args.path)
data = hoge.load_json()
else:
raise FileNotFoundError(f'json file: {args.path}')
# Create Routing Index Manager
manager = RoutingIndexManager(data['num_locations'], data['num_vehicles'],
data['starts'], data['ends'])
# Create Routing Model
routing = RoutingModel(manager)
"""
Define weight of each edge
https://developers.google.com/optimization/routing/vrp
"""
distance_callback = create_distance_callback(manager, data)
transit_callback_index = routing.RegisterTransitCallback(distance_callback)
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
"""
Add capacity constraints
https://developers.google.com/optimization/routing/cvrp
"""
demand_callback = create_demand_callback(manager, data)
demand_callback_index = routing.RegisterUnaryTransitCallback(
demand_callback)
add_capacity_constraints(routing, manager, data, demand_callback_index)
"""
Add time window constraints
https://developers.google.com/optimization/routing/vrptw
"""
if 'time_windows' in data.keys():
time_callback = create_time_callback(manager, data)
time_callback_index = routing.RegisterTransitCallback(time_callback)