def dropoff(self):
# print(self.get_location(), self.state.destination_lat, self.state.destination_lon)
assert len(self.__customers) > 0
lenC = len(self.__customers)
assert self.get_location() == self.__customers[lenC-1].get_destination()
if FLAGS.enable_pooling:
# print("DropOff, pooling!")
lenC = len(self.__customers)
self.state.travel_dist += great_circle_distance(self.__customers[0].get_origin()[0], self.__customers[0].get_origin()[1],
self.__customers[lenC-1].get_destination()[0], self.__customers[lenC-1].get_destination()[1])
# print("Dist: ", self.state.travel_dist)
# print("Trip: ", great_circle_distance(self.__customers[0].get_origin()[0], self.__customers[0].get_origin()[1],
# self.__customers[lenC-1].get_destination()[0], self.__customers[lenC-1].get_destination()[1]))
for i in range(lenC):
# print("Trip: ", lenC)
customer = self.__customers.pop(0)
self.earnings += customer.make_payment(self.state.current_capacity, self.state.driver_base_per_trip)
customer.get_off()
else:
# print("Dropoff, not pooling!")
customer = self.__customers.pop(0)
customer.get_off()
self.earnings += customer.make_payment(1, self.state.driver_base_per_trip)
self.state.travel_dist += great_circle_distance(customer.get_origin()[0], customer.get_origin()[1],
customer.get_destination()[0],
customer.get_destination()[1])
self.state.current_capacity = 0
self.__customers_ids = []
self.__change_to_idle()
# latest_cust_id = self.state.assigned_customer_id.pop(0)
self.__reset_plan()
self.__log()
def match(self, current_time, vehicles, requests):
assignments = []
vehicles, vehicles_tocharge = self.find_available_vehicles(vehicles)
n_vehicles = len(vehicles)
if n_vehicles == 0:
return assignments
# List of distances for all available vehicles to requests' origin points
d = great_circle_distance(vehicles.lat.values, vehicles.lon.values,
requests.origin_lat.values[:, None],
requests.origin_lon.values[:, None])
for ridx, request_id in enumerate(requests.index):
vidx = d[ridx].argmin(
) # Retrieving the min distance (nearest vehicle to request)
# Check if it is within the acceptable range of travelling distance
if d[ridx, vidx] < self.reject_distance:
vehicle_id = vehicles.index[vidx]
duration = d[ridx, vidx] / 8.0
distance = d[ridx, vidx]
assignments.append(
self.create_matching_dict(vehicle_id, request_id, duration,
distance))
d[:, vidx] = float('inf')
else:
continue
if len(assignments) == n_vehicles:
return assignments
return assignments
def init_price(self, match_commands):
m_commands = []
for c in match_commands:
vehicle = VehicleRepository.get(c["vehicle_id"])
# vehicle.state.status = status_codes.V_ASSIGNED
if vehicle is None:
print("Invalid Vehicle id")
continue
customer = CustomerRepository.get(c["customer_id"])
if customer is None:
print("Invalid Customer id")
continue
triptime = c["duration"]
# if FLAGS.enable_pricing:
dist_for_pickup = c["distance"]
dist_till_dropoff = great_circle_distance(
customer.get_origin()[0],
customer.get_origin()[1],
customer.get_destination()[0],
customer.get_destination()[1])
total_trip_dist = dist_for_pickup + dist_till_dropoff
[travel_price, wait_price] = vehicle.get_price_rates()
# v_cap = vehicle.state.current_capacity
initial_price = calculate_price(total_trip_dist, triptime,
vehicle.state.mileage,
travel_price, wait_price,
vehicle.state.gas_price,
vehicle.state.driver_base_per_trip)
c["init_price"] = initial_price
m_commands.append(c)
# print(c)
return m_commands
def compute_speed(self, route, triptime):
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(lats[:-1], lons[:-1], lats[1:], lons[1:]) # Distance in meters
speed = sum(distance) / triptime
# print("Dispatch!")
self.state.travel_dist += sum(distance)
return speed
def drive(self, vehicle, timestep):
route = vehicle.get_route() # Sequence of (lon, lat)
speed = vehicle.get_speed()
dist_left = timestep * speed # Remaining Distance
rlats, rlons = zip(
*([vehicle.get_location()] +
route)) # New vehicle location after driving this route
step_dist = geoutils.great_circle_distance(
rlats[:-1], rlons[:-1], rlats[1:],
rlons[1:]) # Get distcnace in meters
# print(step_dist)
# print(type(step_dist))
vehicle.state.travel_dist += dist_left
for i, d in enumerate(step_dist):
if dist_left < d:
bearing = geoutils.bearing(
rlats[i], rlons[i], rlats[i + 1],
rlons[i + 1]) # Calculate angle of motion
next_location = geoutils.end_location(
rlats[i], rlons[i], dist_left,
bearing) # Calculate nxt location
vehicle.update_location(
next_location, route[i + 1:]
) # Updating location based on route's nxt (lon, lat)
return
dist_left -= d
if len(route) > 0:
vehicle.update_location(route[-1], []) # Go the last step
def compute_speed(self, route, triptime):
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(lats[:-1], lons[:-1], lats[1:], lons[1:]) # Distance in meters
speed = sum(distance) / triptime
self.state.travel_dist += sum(distance)
self.state.SOC -= sum(distance)*METER_PER_MILE/self.get_mile_of_range() # meter to mile
return speed
def eta_many_to_many(self,
origins,
destins,
max_distance=5000,
ref_speed=5.0):
T = np.full((len(origins), len(destins)), np.inf)
origins_lat, origins_lon = zip(*origins)
destins_lat, destins_lon = zip(*destins)
origins_lat, origins_lon, destins_lat, destins_lon = map(
np.array, [origins_lat, origins_lon, destins_lat, destins_lon])
origins_x, origins_y = mesh.lon2X(origins_lon), mesh.lat2Y(origins_lat)
destins_x, destins_y = mesh.lon2X(destins_lon), mesh.lat2Y(destins_lat)
d = geoutils.great_circle_distance(origins_lat[:, None],
origins_lon[:, None], destins_lat,
destins_lon)
for i, (x, y) in enumerate(zip(origins_x, origins_y)):
for j in np.where(d[i] < max_distance)[0]:
axi = destins_x[j] - x + MAX_MOVE
ayi = destins_y[j] - y + MAX_MOVE
if 0 <= axi and axi <= 2 * MAX_MOVE and 0 <= ayi and ayi <= 2 * MAX_MOVE:
ref_d = self.ref_d[x, y, axi, ayi]
if ref_d == 0:
T[i, j] = d[i, j] / ref_speed
else:
T[i, j] = self.tt_map[x, y, axi, ayi] * d[i, j] / ref_d
return [T, d]
def eta_many_to_many(self, origins, destins):
origins_lon, origins_lat = zip(*origins)
destins_lon, destins_lat = zip(*destins)
origins_lon, origins_lat, destins_lon, destins_lat = map(
np.array, [origins_lon, origins_lat, destins_lon, destins_lat])
d = geoutils.great_circle_distance(origins_lon[:, None],
origins_lat[:, None], destins_lon,
destins_lat)
return d
def filter_candidates(self, vehicles, requests):
d = great_circle_distance(vehicles.lat.values, vehicles.lon.values,
requests.origin_lat.mean(),
requests.origin_lon.mean())
within_limit_distance = d < self.reject_distance + self.unit_length * (
self.k - 1)
candidates = vehicles.index[within_limit_distance]
d = d[within_limit_distance]
return candidates[np.argsort(d)[:2 * len(requests) + 1]].tolist()
def filter_CS_candidates(self, vehicles, charging_stations):
d = great_circle_distance(vehicles.lat.values, vehicles.lon.values,
mean(charging_stations[:, 0]),
mean(charging_stations[:, 1]))
within_limit_distance = d < 1e3 * (
self.reject_distance + self.unit_length *
(self.k - 1)) # a large enough number
candidates = vehicles.index[within_limit_distance]
d = d[within_limit_distance]
return candidates[np.argsort(d)[:2 * len(charging_stations) +
1]].tolist()
def remove_outliers(df):
df['distance'] = great_circle_distance(df.origin_lat, df.origin_lon,
df.destination_lat,
df.destination_lon).astype(int)
df['speed'] = df.distance / df.trip_time / 1000 * 3600 # km/h
df['rpm'] = df.fare / df.trip_time * 60 # $/m
df = df[(df.trip_time > 60) & (df.trip_time < 3600 * 2)]
df = df[(df.distance > 100) & (df.distance < 100000)]
df = df[(df.speed > 2) & (df.speed < 80)]
df = df[(df.rpm < 3.0) & (df.rpm > 0.3)]
return df.drop(['distance', 'speed', 'rpm'], axis=1)
def create_reachable_map(engine):
lon0, lat0 = convert_xy_to_lonlat(0, 0)
lon1, lat1 = convert_xy_to_lonlat(1, 1)
d_max = great_circle_distance(lat0, lon0, lat1, lon1) / 2.0
points = []
for x, y in state_space:
lon, lat = convert_xy_to_lonlat(x, y)
points.append((lat, lon))
nearest_roads = engine.nearest_road(points)
reachable_map = np.zeros((MAP_WIDTH, MAP_HEIGHT), dtype=np.float32)
for (x, y), (latlon, d) in zip(state_space, nearest_roads):
if d < d_max:
reachable_map[x, y] = 1
return reachable_map
def __init__(self):
self.tt_map = np.load(os.path.join(DATA_DIR, 'tt_map.npy'))
self.routes = pickle.load(open(os.path.join(DATA_DIR, 'routes.pkl'), 'rb'))
d = self.tt_map.copy()
for x in range(d.shape[0]):
origin_lon = mesh.X2lon(x)
for y in range(d.shape[1]):
origin_lat = mesh.Y2lat(y)
for axi in range(d.shape[2]):
x_ = x + axi - MAX_MOVE
destin_lon = mesh.X2lon(x_)
for ayi in range(d.shape[3]):
y_ = y + ayi - MAX_MOVE
destin_lat = mesh.Y2lat(y_)
d[x, y, axi, ayi] = geoutils.great_circle_distance(
origin_lat, origin_lon, destin_lat, destin_lon)
self.ref_d = d
def init_price(self, match_commands):
m_commands = []
for c in match_commands:
vehicle = VehicleRepository.get(c["vehicle_id"])
# vehicle.state.status = status_codes.V_ASSIGNED
if vehicle is None:
print("Invalid Vehicle id")
continue
customer = CustomerRepository.get(c["customer_id"])
if customer is None:
print("Invalid Customer id")
continue
triptime = c["duration"]
# if FLAGS.enable_pricing:
dist_for_pickup = c["distance"]
od_route = self.routing_engine.route_time([
(customer.get_origin(), customer.get_destination())
])
# dist_dropoff = great_circle_distance(customer.get_origin()[0], customer.get_origin()[1],
# customer.get_destination()[0], customer.get_destination()[1])
route, time = od_route[0]
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(
lats[:-1], lons[:-1], lats[1:], lons[1:]) # Distance in meters
dist_till_dropoff = sum(distance)
# print(dist_dropoff, dist_till_dropoff)
total_trip_dist = dist_for_pickup + dist_till_dropoff
[travel_price, wait_price] = vehicle.get_price_rates()
# v_cap = vehicle.state.current_capacity
initial_price = calculate_price(total_trip_dist, triptime,
vehicle.state.mileage,
travel_price, wait_price,
vehicle.state.gas_price,
vehicle.state.driver_base_per_trip)
c["init_price"] = initial_price
m_commands.append(c)
# print(c)
return m_commands
def drive(self, vehicle, timestep):
route = vehicle.get_route()
speed = vehicle.get_speed()
dist_left = timestep * speed
rlats, rlons = zip(*([vehicle.get_location()] + route))
step_dist = geoutils.great_circle_distance(rlats[:-1], rlons[:-1],
rlats[1:], rlons[1:])
for i, d in enumerate(step_dist):
if dist_left < d:
bearing = geoutils.bearing(rlats[i], rlons[i], rlats[i + 1],
rlons[i + 1])
next_location = geoutils.end_location(rlats[i], rlons[i],
dist_left, bearing)
vehicle.update_location(next_location, route[i + 1:])
return
dist_left -= d
if len(route) > 0:
vehicle.update_location(route[-1], [])
def match(self, current_time, vehicles, requests):
assignments = []
vehicles = self.find_available_vehicles(vehicles)
n_vehicles = len(vehicles)
if n_vehicles == 0:
return assignments
d = great_circle_distance(vehicles.lat.values, vehicles.lon.values,
requests.origin_lat.values[:, None],
requests.origin_lon.values[:, None])
for ridx, request_id in enumerate(requests.index):
vidx = d[ridx].argmin()
if d[ridx, vidx] < self.reject_distance:
vehicle_id = vehicles.index[vidx]
duration = d[ridx, vidx] / 8.0
assignments.append(
self.create_command(vehicle_id, request_id, duration))
d[:, vidx] = float('inf')
else:
continue
if len(assignments) == n_vehicles:
return assignments
return assignments
def dropoff(self,tick):
# print(self.get_location(), self.state.destination_lat, self.state.destination_lon)
assert len(self.__customers) > 0
lenC = len(self.__customers)
# assert self.get_location() == self.__customers[lenC-1].get_destination_lonlat()
self.state.current_hex = self.__customers[lenC-1].get_destination_id()
customer = self.__customers.pop(0)
customer.get_off()
self.customer_payment = customer.make_payment(1, self.state.driver_base_per_trip)
self.earnings += self.customer_payment
trip_distance = great_circle_distance(customer.get_origin()[0], customer.get_origin()[1],
customer.get_destination()[0],
customer.get_destination()[1])
self.state.travel_dist += trip_distance
self.state.SOC -= trip_distance*METER_PER_MILE/self.get_mile_of_range() # meter to mile
self.rb_next_state = [tick,self.get_id(),self.state.current_hex,self.get_SOC()]
self.rb_reward = BETA_EARNING* self.customer_payment - BETA_COST*self.compute_charging_cost(trip_distance) - SOC_PENALTY*(1-self.get_SOC())
if self.state.status == status_codes.V_OFF_DUTY:
self.flag = 1
# specify it
if self.get_SOC() <0:
self.rb_reward -= 50 # additional penalty for running out battery
self.state.SOC = self.state.target_SOC
self.__set_destination(self.get_location(), PENALTY_CHARGING_TIME) # 45 min for emergency charging
self.__change_to_cruising()
self.recent_transitions.append((self.rb_state,self.rb_action,self.rb_next_state,self.rb_reward,self.flag))
# self.dqn_network.dump_transitions(self.recent_transitions[-1])
return
self.recent_transitions.append((self.rb_state,self.rb_action,self.rb_next_state,self.rb_reward,self.flag))
# self.dump_replay_buffer()
# self.dqn_network.dump_transitions(self.recent_transitions[-1])
self.state.current_capacity = 0
self.__customers_ids = []
self.__change_to_idle()
# latest_cust_id = self.state.assigned_customer_id.pop(0)
self.__reset_plan()
self.__log()
def propose_price(self, vehicle, price, request):
if len(vehicle.q_action_dict) == 0:
# print("NOT DISPATCHED BEFORE!")
return price
else:
# print(self.q_action_dict)
r_lon, r_lat = request.origin_lon, request.origin_lat
r_x, r_y = mesh.convert_lonlat_to_xy(r_lon, r_lat)
# print("ID: ", self.state.id)
# print("Request: ", r_x, r_y)
sorted_q = {
k: v
for k, v in sorted(vehicle.q_action_dict.items(),
key=lambda item: item[1],
reverse=True)
}
# print("Sorted: ", sorted_q)
# print("Epsilon: ", self.epsilon, len(self.q_action_dict))
filtered_q = list(islice(sorted_q, vehicle.epsilon))
# filtered_q = dict(filtered_q)
# print("Filtered: ", filtered_q)
if (r_x, r_y) in filtered_q:
# print("Here!")
return price
if (r_x, r_y) in vehicle.q_action_dict.keys():
# print("Exists!")
# req_q = self.q_action_dict.get((r_x,r_y))
rank = 0
index = 0
for (kx, ky), v in sorted_q.items():
# print((kx,ky), (r_x, r_y))
if (kx, ky) == (r_x, r_y):
rank = index
index += 1
else:
# print("Does not exist!")
dist_list = {}
for (kx, ky), v in vehicle.q_action_dict.items():
k_lon, k_lat = mesh.convert_xy_to_lonlat(kx, ky)
dist = great_circle_distance(r_lat, r_lon, k_lat, k_lon)
dist_list[(kx, ky)] = dist
# print("D: ", dist_list)
min_dist = np.min(list(dist_list.values()))
(min_x, min_y) = list(dist_list.keys())[list(
dist_list.values()).index(min_dist)]
req_q = vehicle.q_action_dict.get((min_x, min_y))
# print(min_dist, (min_x,min_y), req_q)
rank = 0
index = 0
for (kx, ky), v in sorted_q.items():
if (kx, ky) == (min_x, min_y):
rank = index
index += 1
# print("Rank: ", rank, len(self.q_action_dict))
rank = 1 - (rank / len(vehicle.q_action_dict))
# print("Rank_: ", rank, (self.state.driver_base_per_trip/100))
return price + (rank * 0.5 *
(vehicle.state.driver_base_per_trip / 100))
def compute_speed(self, route, triptime):
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(lats[:-1], lons[:-1],
lats[1:], lons[1:])
speed = sum(distance) / triptime
return speed
def generate_plan(self, vehicle, cust_list, new_customer):
# print("In Plan: ", vehicle.get_id())
time_till_pickup = 0
insertion_cost = 0
# distance_till_dropoff = 0
if len(cust_list) == 1 & len(vehicle.current_plan) == 0:
vehicle.current_plan.append(new_customer.get_origin())
vehicle.current_plan.append(new_customer.get_destination())
vehicle.ordered_pickups_dropoffs_ids.append(new_customer.get_id())
vehicle.ordered_pickups_dropoffs_ids.append(new_customer.get_id())
vehicle.pickup_flags.append(1)
vehicle.pickup_flags.append(0)
routes_till_pickup = [(vehicle.get_location(),
vehicle.current_plan[0])]
routes = self.routing_engine.route_time(routes_till_pickup)
for (route, time) in routes:
time_till_pickup += time
od_pairs = [(vehicle.get_location(), vehicle.current_plan[0]),
(vehicle.current_plan[0], vehicle.current_plan[1])]
routes = self.routing_engine.route_time(od_pairs)
for (route, time) in routes:
vehicle.current_plan_routes.append([route, time])
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(
lats[:-1], lons[:-1], lats[1:],
lons[1:]) # Distance in meters
insertion_cost += sum(distance)
else:
new_list = [
new_customer.get_origin(),
new_customer.get_destination()
]
# print(new_list)
final_pickup_flags = []
final_plan = []
final_pickups_dropoffs_ids = []
final_routes = []
min_distance = np.inf
min_time = np.inf
pickup_index = 0
# all_options = vehicle.current_plan + new_list
# print(all_options)
# perm = list(itertools.permutations(all_options))
# print(perm)
# print(len(set(perm)))
# print("Insert Pickup")
for pos in range(len(vehicle.current_plan) + 1):
# print(vehicle.current_plan)
new_plan = vehicle.current_plan[:pos]
new_pickup_flags = vehicle.pickup_flags[:pos]
new_pickups_dropoffs_ids = vehicle.ordered_pickups_dropoffs_ids[:
pos]
new_plan.append(new_list[0])
new_pickup_flags.append(1)
new_pickups_dropoffs_ids.append(new_customer.get_id())
new_plan.extend(vehicle.current_plan[pos:])
new_pickup_flags.extend(vehicle.pickup_flags[pos:])
new_pickups_dropoffs_ids.extend(
vehicle.ordered_pickups_dropoffs_ids[pos:])
# print("List: ", new_plan, new_pickup_flags, new_pickups_dropoffs_ids)
od_pairs = [(vehicle.get_location(), new_plan[0])]
od_pairs.extend([(new_plan[x], new_plan[x + 1])
for x in range(len(new_plan) - 1)])
# print(od_pairs)
total_time = 0
total_dist = 0
potential_routes_time = self.routing_engine.route_time(
od_pairs)
new_routes = []
index = 0
wait_time = 0
# pickup_distance = 0
for (route, time) in potential_routes_time:
total_time += time
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(
lats[:-1], lons[:-1], lats[1:],
lons[1:]) # Distance in meters
total_dist += sum(distance)
new_routes.append([route, time])
if index < pos + 1:
wait_time += time
# pickup_distance += sum(distance)
index += 1
# print("Pos: ", pos, "Wait: ", wait_time)
# print("T: ", total_time)
# print("D: ", total_dist)
if (total_time < min_time) | (total_dist < min_distance):
min_time = total_time
min_distance = total_dist
insertion_cost = total_dist
final_pickup_flags = new_pickup_flags
final_plan = new_plan
final_pickups_dropoffs_ids = new_pickups_dropoffs_ids
pickup_index = pos
final_routes = new_routes
time_till_pickup = wait_time
# distance_till_pickup = pickup_distance
# print("Min: ", min_time, min_distance)
vehicle.current_plan = final_plan
vehicle.pickup_flags = final_pickup_flags
vehicle.ordered_pickups_dropoffs_ids = final_pickups_dropoffs_ids
vehicle.current_plan_routes = final_routes
final_pickup_flags = []
final_plan = []
final_pickups_dropoffs_ids = []
final_routes = []
min_distance = np.inf
min_time = np.inf
# print("Insert Drop-off! ", pickup_index, time_till_pickup, vehicle.current_plan)
for pos in range(len(vehicle.current_plan) + 1):
if pos <= pickup_index:
continue
# print(vehicle.current_plan)
new_plan = vehicle.current_plan[:pos]
new_pickup_flags = vehicle.pickup_flags[:pos]
new_pickups_dropoffs_ids = vehicle.ordered_pickups_dropoffs_ids[:
pos]
new_plan.append(new_list[1])
new_pickup_flags.append(0)
new_pickups_dropoffs_ids.append(new_customer.get_id())
new_plan.extend(vehicle.current_plan[pos:])
new_pickup_flags.extend(vehicle.pickup_flags[pos:])
new_pickups_dropoffs_ids.extend(
vehicle.ordered_pickups_dropoffs_ids[pos:])
# print("List: ", new_plan, new_pickup_flags, new_pickups_dropoffs_ids)
od_pairs = [(vehicle.get_location(), new_plan[0])]
od_pairs.extend([(new_plan[x], new_plan[x + 1])
for x in range(len(new_plan) - 1)])
total_time = 0
total_dist = 0
potential_routes_time = self.routing_engine.route_time(
od_pairs)
# print(len(new_plan)+1, len(od_pairs), len(potential_routes_time))
new_routes = []
# counter = 0
# dropoff_distance = 0
for (route, time) in potential_routes_time:
total_time += time
lats, lons = zip(*route)
distance = geoutils.great_circle_distance(
lats[:-1], lons[:-1], lats[1:],
lons[1:]) # Distance in meters
total_dist += sum(distance)
new_routes.append([route, time])
# if pickup_index < counter < pos+1:
# dropoff_distance += sum(distance)
# counter += 1
# print("T: ", total_time)
# print("D: ", total_dist)
if (total_time < min_time) | (total_dist < min_distance):
min_time = total_time
min_distance = total_dist
insertion_cost = total_dist
final_pickup_flags = new_pickup_flags
final_plan = new_plan
final_pickups_dropoffs_ids = new_pickups_dropoffs_ids
final_routes = new_routes
# distance_till_dropoff = dropoff_distance
# print("Min: ", min_time, min_distance)
vehicle.current_plan = np.copy(final_plan).tolist()
vehicle.pickup_flags = np.copy(final_pickup_flags).tolist()
vehicle.ordered_pickups_dropoffs_ids = np.copy(
final_pickups_dropoffs_ids).tolist()
vehicle.current_plan_routes = np.copy(final_routes).tolist()
# print("Generated Plan: ", vehicle.current_plan)
# dist_time = []
# for (route, time) in vehicle.current_plan_routes:
# lats, lons = zip(*route)
# distance = geoutils.great_circle_distance(lats[:-1], lons[:-1], lats[1:],lons[1:]) # Distance in meters
# dist = sum(distance)
# dist_time.append([dist, time])
# print("Routes: ", dist_time)
# print(time_till_pickup, distance_till_pickup, distance_till_dropoff)
# print("Nxt!!")
return insertion_cost, time_till_pickup
def init_price(self, match_commands, charging_commands):
m_commands = []
for m in match_commands:
vehicle = VehicleRepository.get(m["vehicle_id"])
# vehicle.state.status = status_codes.V_ASSIGNED
if vehicle is None:
print("Invalid Vehicle id")
continue
customer = CustomerRepository.get(m["customer_id"])
if customer is None:
print("Invalid Customer id")
continue
triptime = m["duration"]
# if FLAGS.enable_pricing:
dist_for_pickup = m["distance"]
dist_till_dropoff = great_circle_distance(
customer.get_origin()[0],
customer.get_origin()[1],
customer.get_destination()[0],
customer.get_destination()[1])
total_trip_dist = dist_for_pickup + dist_till_dropoff
[travel_price, wait_price] = vehicle.get_price_rates()
# v_cap = vehicle.state.current_capacity
initial_price = calculate_price(total_trip_dist, triptime,
vehicle.state.mileage,
travel_price, wait_price,
vehicle.state.gas_price,
vehicle.state.driver_base_per_trip)
m["init_price"] = initial_price
m_commands.append(m)
# matching_charging_station
c_commands = [] # charging command
for c in charging_commands:
vehicle = VehicleRepository.get(c["vehicle_id"])
if vehicle is None:
print("Invalid Vehicle id")
continue
charging_pile = ChargingRepository.get_charging_station(
c["customer_id"])
# charging_pile = df_charging_piles["customer_id"] # return to that row
if charging_pile is None:
print("Invalid Customer id")
continue
charging_incentives = 0 # charging_pile.get_incentive()
triptime = c["duration"]
# if FLAGS.enable_pricing:
dist_to_cs = c["distance"]
total_trip_dist = dist_to_cs
[travel_price, wait_price] = vehicle.get_price_rates()
# v_cap = vehicle.state.current_capacity
initial_price = calculate_price(total_trip_dist, triptime,
vehicle.state.mile_of_range,
travel_price, wait_price,
vehicle.state.full_charge_price,
vehicle.state.driver_base_per_trip)
c["init_price"] = initial_price + charging_incentives
c_commands.append(c)
return m_commands, c_commands
