def step(self): for customer in CustomerRepository.get_all(): customer.step(self.__dt) if customer.is_arrived() or customer.is_disappeared(): CustomerRepository.delete(customer.get_id()) for vehicle in VehicleRepository.get_all(): vehicle.step(self.__dt) # vehicle.print_vehicle() if vehicle.exit_market(): score = ','.join( map(str, [ self.get_current_time(), vehicle.get_id(), vehicle.get_total_dist(), vehicle.compute_profit() ] + vehicle.get_score())) if vehicle.agent_type == agent_codes.dqn_agent: self.current_dqnV -= 1 else: self.current_dummyV -= 1 sim_logger.log_score(score) VehicleRepository.delete(vehicle.get_id()) self.__populate_new_customers() self.__update_time() if self.__t % 3600 == 0: # print("Elapsed : {}".format(get_local_datetime(self.__t))) self.logger.info("Elapsed : {}".format(get_local_datetime( self.__t)))
def reset(self, start_time=None, timestep=None): if start_time is not None: self.__t = start_time if timestep is not None: self.__dt = timestep VehicleRepository.init() CustomerRepository.init()
def dispatch_vehicles(self, commands): # print("D: ", commands) od_pairs = [] vehicles = [] # Comamnd is a dictionary created in dummy_agent for command in commands: vehicle = VehicleRepository.get(command["vehicle_id"]) if vehicle is None: self.logger.warning("Invalid Vehicle id") continue if "offduty" in command: off_duration = self.sample_off_duration() # Rand time to rest vehicle.take_rest(off_duration) elif "cache_key" in command: l, a = command["cache_key"] route, triptime = self.routing_engine.get_route_cache(l, a) vehicle.cruise(route, triptime) else: vehicles.append(vehicle) od_pairs.append( (vehicle.get_location(), command["destination"])) routes = self.routing_engine.route(od_pairs) for vehicle, (route, triptime) in zip(vehicles, routes): if triptime == 0: continue vehicle.cruise(route, triptime)
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 populate_vehicle(self, vehicle_id, location): type = 0 r = randrange(2) if r == 0 and self.current_dummyV < FLAGS.dummy_vehicles: type = agent_codes.dummy_agent self.current_dummyV += 1 # If r = 1 or num of dummy agent satisfied elif self.current_dqnV < FLAGS.dqn_vehicles: type = agent_codes.dqn_agent self.current_dqnV += 1 else: type = agent_codes.dummy_agent self.current_dummyV += 1 VehicleRepository.populate(vehicle_id, location, type)
def predict_best_action(self, vehicle_id, vehicle_state): if vehicle_state.idle_duration >= MIN_DISPATCH_CYCLE and FLAGS.offduty_probability > np.random.random( ): a, offduty = (0, 0), 1 elif self.q_network is None: a, offduty = (0, 0), 0 else: x, y = mesh.convert_lonlat_to_xy(vehicle_state.lon, vehicle_state.lat) if (x, y) in self.q_cache: actions, Q, amax = self.q_cache[(x, y)] else: # Get state features and action features s, actions = self.feature_constructor.construct_current_features( x, y) # print("A: ", actions, len(actions)) # print("S: ", s) # Calculate Q values based on state features Q = self.q_network.compute_q_values(s) # print("Q values: ", Q) # only considers actions whose values are greater than wait action value wait_action_value = Q[0] actions = [ a for a, q in zip(actions, Q) if q >= wait_action_value ] Q = Q[Q >= wait_action_value] # print("Q ba: ", Q) amax = np.argmax(Q) # Get the index of the max value # print("Q max, val, max: ", amax, Q[amax], max(Q)) self.q_cache[(x, y)] = actions, Q, amax # Save in cache # if actions[amax] == (0, 0): # aidx = amax # else: aidx = self.q_network.get_action( Q, amax) # Get action with max Q value a = actions[aidx] offduty = 1 if Q[aidx] < FLAGS.offduty_threshold else 0 # print("Chosen A: ", a) vehicle = VehicleRepository.get(vehicle_id) # tmp_q_action = {a:q for a, q in zip(actions, Q)} q_action = {(x + ax, y + ay): q for (ax, ay), q in zip(actions, Q)} vehicle.q_action_dict = q_action vehicle.epsilon = int(len(vehicle.q_action_dict) * 0.05) # print("Loc: ", x, " , ", y) # print("Act: ", tmp_q_action) # print("Added:", vehicle.q_action_dict) return a, offduty
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 startup_dispatch(self, current_time, vehicles): self.dispatch_policy.update_state(current_time, vehicles) if FLAGS.train: self.dispatch_policy.give_rewards(vehicles) dispatch_commands = self.dispatch_policy.get_dispatch_decisions(vehicles) self.dispatch_policy.record_dispatch(vehicles.index, current_time) for vid in vehicles.index: vehicle = VehicleRepository.get(vid) vehicle.first_dispatched = 1 ######### Only with the DQN agent not the dummy ############# if FLAGS.train: self.dispatch_policy.backup_supply_demand() # If size exceeded, run training if len(self.dispatch_policy.supply_demand_history) > INITIAL_MEMORY_SIZE: average_loss, average_q_max = self.dispatch_policy.train_network(FLAGS.batch_size) # print("iterations : {}, average_loss : {:.3f}, average_q_max : {:.3f}".format( # self.q_network.n_steps, average_loss, average_q_max), flush=True) self.dispatch_policy.q_network.write_summary(average_loss, average_q_max) return dispatch_commands
def give_rewards(self, vehicles): for vehicle_id, row in vehicles.iterrows(): vehicle = VehicleRepository.get(vehicle_id) earnings = row.earnings - self.last_earnings.get(vehicle_id, 0) cost = vehicle.compute_fuel_consumption() if earnings > 0: cost -= self.last_cost.get(vehicle_id, 0) profit = earnings - cost else: profit = earnings # print("Earnings: ", earnings, "Cost: ", cost, "Profit: ", profit) self.rewards[vehicle_id] += ( 12 * profit ) - 5 * row.pickup_time + 10 * settings.STATE_REWARD_TABLE[ row.status] # self.rewards[vehicle_id] += earnings + settings.STATE_REWARD_TABLE[row.status] self.last_earnings[vehicle_id] = row.earnings if earnings > 0: self.last_cost[vehicle_id] = vehicle.compute_fuel_consumption() if row.status == status_codes.V_OFF_DUTY: self.last_state_actions[vehicle_id] = None
def get_vehicles(self): return VehicleRepository.get_all()
def get_vehicles_state(self): return VehicleRepository.get_states()
def match_RS(self, current_time, vehicles, requests): # print("SA: Inside GreedyMatching Match ", "V:", len(vehicles), "R:", len(requests)) commands = [] requestAssigned = defaultdict(list) vehicles, cap_list = self.find_available_vehicles_RS(vehicles) n_vehicles = len(vehicles) # nV = 4 * len(requests) nV = sum(cap_list) ######### Updated based on capacity # print(nV) if (n_vehicles > nV): vehicles = vehicles.iloc[range(nV), :] # print("SA: Inside GreedyMatching Match ", "V:", len(vehicles), "R:", len(requests)) if n_vehicles == 0: return commands # print("Available Vehicles and grid locations") v_latlon = vehicles[["lat", "lon"]] V = defaultdict(list) vid2coord = {} all_candidate_vids = [] # all_candidate_vidx = {} # vcnt = 0 for vid, row in v_latlon.iterrows(): # print("AAAA") # print(vehicles.loc[vid]) # print(vid, row.lon, row.lat) coord = self.get_coord(row.lon, row.lat) vid2coord[vid] = coord # print(vid, coord) V[coord].append(vid) all_candidate_vids.append(vid) # all_candidate_vidx[vid] = vcnt # vcnt = vcnt+1 # print("Requests and Grid locations") r_latlon = requests[["origin_lat", "origin_lon"]] R = defaultdict(list) all_target_rids = [] for rid, row in r_latlon.iterrows(): coord = self.get_coord(row.origin_lon, row.origin_lat) # print(rid, coord) R[coord].append(rid) all_target_rids.append(rid) # print("Candidate IDs: ", all_candidate_vids) # print("Target IDs: ", all_target_rids) # Dictionary of vehicle IDs and their index in the candidate list all_candidate_vidx = dict( zip(all_candidate_vids, range(len(all_candidate_vids)))) # print("All Candidates: ", all_candidate_vidx, len(all_candidate_vids)) all_target_ridx = dict( zip(all_target_rids, range(len(all_target_rids)))) # print("All targets: ", all_target_ridx, len(all_target_rids)) target_ridx = [all_target_ridx[r] for r in all_target_rids] reject_range = int( self.reject_distance / self.unit_length / self.k) + 1 d_latlon = requests[["destination_lon", "destination_lat"]] candidate_latlon = v_latlon.loc[all_candidate_vids] # print("Cand List: ", len(candidate_latlon)) all_target_latlon = r_latlon.loc[all_target_rids] # print("Target List: ", len(all_target_latlon)) all_destination_latlon = r_latlon.loc[all_target_rids] T, dist = self.eta_matrix(candidate_latlon, all_target_latlon) # print("match_D: ", dist, dist.shape) TRR, Dist_RR = self.eta_matrix(all_target_latlon, all_target_latlon) TDD, Dist_DD = self.eta_matrix(all_destination_latlon, all_destination_latlon) # for vid, row in vehicles.iterrows(): # row.earnings = 10 # print(type(row)) # print(vehicles[["id"]]) # print(vid, row.earnings, row.lon, row.lat, row.status) for coord in self.coord_iter(): # print("SA: Inside COORD") # print(dist.shape) # print(T.shape) if not R[coord]: # print(coord, "does not exist") continue # print(coord, "exists") # for i in range(int(np.ceil(len(R[coord]) / self.max_locations))): # target_rids = R[coord][i * self.max_locations : (i + 1) * self.max_locations] # for i in range(int(np.ceil(len(R[coord]) / self.max_locations))): target_rids = R[coord] # print("TR: ", target_rids) candidate_vids = self.find_candidates(coord, len(target_rids), V, reject_range) # print("Cand. Vehicles: ", len(candidate_vids)) if len(candidate_vids) == 0: continue target_latlon = r_latlon.loc[target_rids] candidate_vids = self.filter_candidates( v_latlon.loc[candidate_vids], target_latlon) # print("Filtered Vehicles: ", len(candidate_vids)) if len(candidate_vids) == 0: continue requestAssigned = defaultdict(list) # All candiaidate vehicles that can pickup this specific customer candidate_vidx = [all_candidate_vidx[v] for v in candidate_vids] assignments = self.assign_nearest_vehicle_RideShare( target_rids, all_target_ridx, requestAssigned, candidate_vids, candidate_vidx, T.T, TRR, TDD, dist.T, Dist_RR, Dist_DD) for vid, rid, tt, d in assignments: commands.append(self.create_matching_dict(vid, rid, tt, d)) # vehicles[vid].current_capacity = vehicles[vid].current_capacity +1 # print("COORD:", coord, "V ", vid, "assigned to R", rid) vehicle = VehicleRepository.get(vid) # vehicle.state.current_capacity += 1 # vehicle.print_vehicle() # print(vehicle) # vehicles[vid].update_capacity() # if vid in V[vid2coord[vid]]: # V[vid2coord[vid]].remove(vid) if vehicle.state.current_capacity >= vehicle.state.max_capacity and vid in V[ vid2coord[vid]]: V[vid2coord[vid]].remove(vid) return commands
# print("B: ", len(requests), len(r_df)) requests = requests.append(r_df, ignore_index=True) sum_requests += len(requests) requests = requests.set_index("id") # print("R After: ", len(requests)) current_time = Sim_experiment.simulator.get_current_time() # For DQN if FLAGS.enable_pricing: # print("All: ", len(vehicles), m) if len(vehicles) > 0: new_vehicles = vehicles.loc[[ vehicle_id for vehicle_id in vehicles.index if VehicleRepository.get( vehicle_id).first_dispatched == 0 ]] startup_dispatch = Sim_experiment.dqn_agent.startup_dispatch( current_time, new_vehicles) Sim_experiment.simulator.dispatch_vehicles( startup_dispatch) # print("Done", len(new_vehicles)) if len(vehicles) == 0: continue else: # print("V1: ", len(vehicles)) m_commands, vehicles = Sim_experiment.central_agent.get_match_commands( current_time, vehicles, requests) # print("V2: ", len(vehicles))
def match_vehicles(self, commands, dqn_agent, dummy_agent): # print("M: ", commands) vehicle_list = [] rejected_requests = [] accepted_commands = {} reject_count = 0 # Comamnd is a dictionary created in dummy_agent # print("########################################################") for command in commands: rejected_flag = 0 # print(command["vehicle_id"], command["customer_id"]) vehicle = VehicleRepository.get(command["vehicle_id"]) # vehicle.state.status = status_codes.V_ASSIGNED if vehicle is None: self.logger.warning("Invalid Vehicle id") continue customer = CustomerRepository.get(command["customer_id"]) if customer is None: self.logger.warning("Invalid Customer id") continue triptime = command["duration"] vid = command["vehicle_id"] # print("Maching: Vehicle " + vehicle.to_string() + " ---> " + customer.to_string()) price_response = command["init_price"] if FLAGS.enable_pricing: # For DQN if vehicle.state.agent_type == agent_codes.dummy_agent: price_response = dummy_agent.get_price_decision( vehicle, command["init_price"], customer.get_request()) elif vehicle.state.agent_type == agent_codes.dqn_agent: price_response = dqn_agent.get_price_decision( vehicle, command["init_price"], customer.get_request()) # price_response = initial_price # print("Diff: ", (price_response-initial_price)) # Now, customer needs to calculate reward and accpet or reject if customer.accpet_reject_ride( price_response, vehicle.state, triptime): # If customer accepts vehicle.head_for_customer(customer.get_origin(), triptime, customer.get_id(), command["distance"]) customer.wait_for_vehicle(triptime) v = VehicleRepository.get(vid) v.state.current_capacity += 1 accepted_commands[reject_count] = command # print(command) # print(accepted_commands) reject_count += 1 # print(len(accepted_commands)) else: # base case: request drops rejected_flag = 1 customer.go_to_nxt_timestep = 1 rejected_requests.append(customer.get_request()) else: customer.accepted_price = command["init_price"] vehicle.head_for_customer(customer.get_origin(), triptime, customer.get_id(), command["distance"]) customer.wait_for_vehicle(triptime) v = VehicleRepository.get(vid) v.state.current_capacity += 1 accepted_commands = commands # vehicle.state.status = status_codes.V_ASSIGNED if FLAGS.enable_pooling: if vid not in vehicle_list and not rejected_flag: vehicle_list.append(vid) if FLAGS.enable_pooling: for vi in vehicle_list: vehicle = VehicleRepository.get(vi) # vehicle.print_vehicle() vehicle.change_to_assigned() return rejected_requests, accepted_commands
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
def match_vehicles(self, commands, dqn_agent, dummy_agent): # print("M: ", commands) vehicle_list = [] rejected_requests = [] accepted_commands = [] num_accepted = 0 # reject_count = 0 vehicle_accepted_cust = defaultdict(list) # od_accepted_pairs = [] # Comamnd is a dictionary created in dummy_agent # print("########################################################") for command in commands: rejected_flag = 0 # print(command["vehicle_id"], command["customer_id"]) vehicle = VehicleRepository.get(command["vehicle_id"]) vid = command["vehicle_id"] # print("V_Loc: ", vehicle.get_location()) # vehicle.state.status = status_codes.V_ASSIGNED if vehicle is None: self.logger.warning("Invalid Vehicle id") continue # print("Vid: ", vid, "Plan: ", vehicle.current_plan) # vehicle_cust_price_time = dict() if (vehicle.state.status == status_codes.V_OCCUPIED ) & vehicle.state.accept_new_request: # print(vid, "Update", vehicle.current_plan, vehicle.get_destination()) if (len(vehicle.current_plan) == 0) & (vehicle.state.destination_lat is not None): # print(vid, "Dest: ", vehicle.get_destination()) vehicle.current_plan = [vehicle.get_destination()] vehicle.current_plan_routes = [ (vehicle.get_route(), vehicle.state.time_to_destination) ] elif (len(vehicle.current_plan) == 0) & (vehicle.state.destination_lat is None): vehicle.change_to_idle() vehicle.reset_plan() elif (len(vehicle.current_plan) != 0) & ( vehicle.get_destination() != vehicle.current_plan[0]): # print(vid, ": ", vehicle.get_destination(), vehicle.current_plan[0]) if vehicle.state.destination_lat is not None: plan = [vehicle.get_destination()] plan.extend(vehicle.current_plan) vehicle.current_plan = np.copy(plan).tolist() if len(vehicle.get_route()) == 0: # print(vid, "Empty Route!!", vehicle.get_destination()) # print(vehicle.current_plan) # print(vehicle.pickup_flags) # print(vehicle.ordered_pickups_dropoffs_ids) # print(vehicle.current_plan_routes) od_routes = self.routing_engine.route_time([ (vehicle.get_location(), vehicle.get_destination()) ]) routes = [od_routes[0]] else: routes = [[ vehicle.get_route(), vehicle.state.time_to_destination ]] routes.extend(vehicle.current_plan_routes) vehicle.current_plan_routes = np.copy(routes).tolist() # if len(vehicle.get_route()) == 0: # print("R: ", vehicle.current_plan_routes) if len(vehicle.current_plan) != len(vehicle.current_plan_routes) != len(\ vehicle.ordered_pickups_dropoffs_ids) != len(vehicle.pickup_flags): print("ERROR!") prev_cost = 0 # For each vehicle # Need to calculate route (and order customer list) before heading to customer for index in range(len(command["customer_id"])): customer = CustomerRepository.get( command["customer_id"][index]) if customer is None: self.logger.warning("Invalid Customer id") continue prev_plan = np.copy(vehicle.current_plan) prev_flags = np.copy(vehicle.pickup_flags) prev_ids = np.copy(vehicle.ordered_pickups_dropoffs_ids) prev_routes = np.copy(vehicle.current_plan_routes) vehicle_accepted_cust[vid].append( command["customer_id"][index]) insertion_cost, waiting_time = self.generate_plan( vehicle, vehicle_accepted_cust[vid], customer) if len(vehicle_accepted_cust[vid]) > 1: # print("prev: ", prev_cost, insertion_cost) insertion_cost = abs(insertion_cost - prev_cost) if insertion_cost == float(0): insertion_cost = command["init_price"][index] # print("L: ", len(vehicle_accepted_cust[vid])) # print("C: ", insertion_cost) [travel_price, wait_price] = vehicle.get_price_rates() init_price = calculate_price( insertion_cost, waiting_time, vehicle.state.mileage, travel_price, wait_price, vehicle.state.gas_price, vehicle.state.driver_base_per_trip) # print("P: ", init_price, command["init_price"][index]) command["duration"][index] = waiting_time command["init_price"][index] = init_price # print("A: ", command) if FLAGS.enable_pricing: # For DQN if vehicle.state.agent_type == agent_codes.dummy_agent: price_response = dummy_agent.get_price_decision( vehicle, init_price, customer.get_request()) elif vehicle.state.agent_type == agent_codes.dqn_agent: price_response = dqn_agent.get_price_decision( vehicle, init_price, customer.get_request()) # price_response = initial_price # print("Diff: ", (price_response-initial_price)) # Now, customer needs to calculate reward and accept or reject if customer.accpet_reject_ride( price_response, vehicle.state, waiting_time): # If customer accepts num_accepted += 1 # if not FLAGS.enable_pooling: # vehicle.head_for_customer(customer.get_origin(), waiting_time, customer.get_id(), command["distance"][index]) vehicle.accepted_customers.append( command["customer_id"][index]) # vehicle.accepted_customers.append([customer, triptime, price_response, command["distance"][index]]) customer.wait_for_vehicle(waiting_time) prev_cost = insertion_cost # vehicle_accepted_cust[vid].append(command["customer_id"][index]) # vehicle.state.current_capacity += 1 accepted_commands.append(command) # print("Accepted, cust: ", customer.get_id(), " ", vehicle.current_plan) else: # rejected_flag = 1 # reject_count += 1 customer.go_to_nxt_timestep = 1 rejected_requests.append(customer.get_request()) # if len(prev_plan) == 0: # print("Should be Empty!") vehicle.current_plan = prev_plan.tolist() vehicle.pickup_flags = prev_flags.tolist() vehicle.ordered_pickups_dropoffs_ids = prev_ids.tolist( ) vehicle.current_plan_routes = prev_routes.tolist() # print("B: ", vehicle.accepted_customers, vehicle_accepted_cust[vid]) # print("Reject: ", vid, " ", customer.get_id()) vehicle_accepted_cust[vid].pop() # vehicle.accepted_customers.pop(0) # print("A: ", vehicle_accepted_cust[vid], len(vehicle_accepted_cust[vid]), vehicle.accepted_customers) # print("Rejected, cust: ", customer.get_id(), " ", vehicle.current_plan) else: customer.accepted_price = init_price # if not FLAGS.enable_pooling: # vehicle.head_for_customer(customer.get_origin(), triptime, customer.get_id(), command["distance"][index]) vehicle.accepted_customers.append( command["customer_id"][index]) # vehicle.accepted_customers.append([customer, triptime, price_response, command["distance"][index]]) customer.wait_for_vehicle(waiting_time) prev_cost = insertion_cost accepted_commands = commands # od_accepted_pairs = pairs # vehicle.state.status = status_codes.V_ASSIGNED if FLAGS.enable_pooling: # print("vid: ", vehicle.get_id(), "Accepted: ", len(vehicle_accepted_cust[vid])) vehicle.tmp_capacity = vehicle.state.current_capacity # if vid not in vehicle_list and len(vehicle_accepted_cust[vid]) != 0: # vehicle_list.append(vid) if len(vehicle.current_plan) == 0: # print(vid, "EMPTYYYYYY!") continue else: route, triptime = vehicle.current_plan_routes.pop(0) vehicle.nxt_stop = vehicle.current_plan.pop(0) if len(route) == 0: # print("B: ", triptime, len(vehicle.current_plan), len(vehicle.ordered_pickups_dropoffs_ids), # len(vehicle.current_plan_routes)) r2 = self.routing_engine.route_time([ (vehicle.get_location(), vehicle.nxt_stop) ]) route, triptime = r2[0] # print("Updated: ", triptime, len(route)) # print("Loc: ", vehicle.get_location(), "Nxt: ", vehicle.nxt_stop) cust_id = vehicle.ordered_pickups_dropoffs_ids[0] if triptime == 0.0: # vehicle.current_plan.pop(0) pick_drop = vehicle.pickup_flags.pop(0) cust_id = vehicle.ordered_pickups_dropoffs_ids.pop(0) # print("routes: ", routes) vehicle.state.assigned_customer_id = cust_id if pick_drop == 1: vehicle.state.lat, vehicle.state.lon = CustomerRepository.get( cust_id).get_origin() vehicle.pickup(CustomerRepository.get(cust_id)) else: vehicle.state.lat, vehicle.state.lon = CustomerRepository.get( cust_id).get_destination() vehicle.dropoff(CustomerRepository.get(cust_id)) else: vehicle.head_for_customer(triptime, cust_id, route) # vehicle.nxt_stop = vehicle.current_plan[0] vehicle.change_to_assigned() return rejected_requests, accepted_commands, num_accepted
def assign_nearest_vehicle_RideShare(self, request_ids, all_target_ridx, requestAssigned, vehicle_ids, vehicle_idx, T, TRR, TDD, dist, d_RR, d_DD): assignments = [] # for ri, rid in enumerate(request_ids): # vi = T[ri,vehicle_idx].argmin() # tt = T[ri,vehicle_idx][vi] # for rid in request_ids: # print(len(request_ids), type(request_ids)) # print(len(all_target_ridx), len(vehicle_ids), len(vehicle_idx)) # for ri, rid in enumerate(request_ids): for rid in request_ids: ri = all_target_ridx[rid] # For this request ri, pick the min from all candidate vehicles vi = T[ri, vehicle_idx].argmin() tt = T[ri, vehicle_idx][vi] # print("D: ", dist, "shape: ", dist.shape) # print("Ri:", ri, "Vi: ", vehicle_idx, len(vehicle_idx)) # print("Filtered: ", dist[ri, vehicle_idx]) # print(type(dist)) di = dist[ri, vehicle_idx].argmin() dd = dist[ri, vehicle_idx][di] # else: # dd = dist # print(T[ri]) # print(vehicle_idx) # print(T[ri,vehicle_idx]) # print("RTT","Ri",ri,"Vi",vi,vehicle_ids,tt) if tt > self.reject_wait_time: continue vid = vehicle_ids[vi] vi = vehicle_idx[vi] # print("RTT","VID",vid,"Vix",vi) vehicle = VehicleRepository.get(vid) if (vehicle.reachedCapacity() == False): if (len(requestAssigned[vid]) == 0): requestAssigned[vid].append(rid) # vehicle.state.current_capacity += 1 # print("1: ", dd) assignments.append((vid, rid, tt, dd)) # print("TT",T[:, vi]) # print("TRR",TRR[:, ri]) T[:, vi] = T[:, vi] + TRR[:, ri] dist[:, vi] = d_RR[:, ri] # T[ri, vi] = T[ri, vi] + tt # print("TTA",T[:, vi]) else: ll = list(requestAssigned[vid]) # print("LL",ll) ll.append(rid) # print("RS",requestAssigned[vid]) ll_x = [all_target_ridx[r] for r in ll] maxdd = TDD[ll_x][:, ll_x].max() # extra_d = d_DD[ll_x][:, ll_x].max() # print("LLAfter",ll, "Max Time",maxdd,flush=True) if (maxdd <= self.reject_wait_time): requestAssigned[vid].append(rid) # vehicle.increaseCapacity() assignments.append((vid, rid, tt, dd)) # print("Nxt: ", dd) # print("TT",T[:, vi]) T[:, vi] = T[:, vi] + TRR[:, ri] dist[:, vi] = d_RR[:, ri] # T[ri, vi] = T[ri, vi] + tt # print("TTA",T[:, vi]) else: T[:, vi] = float('inf') dist[:, vi] = float('inf') return assignments