destination = vpai.getParcel(); remainingServiceTime = vpai.timeNeeded(); } else if (!rm.isVehicleDiversionAllowed()) { destination = rm.getDestinationToParcel(vehicle); return VehicleStateObject.create(vehicle.getDTO(), rm.getPosition(vehicle), conn, contents, remainingServiceTime,
private List<Truck> findTrucks() { final Point reference = convertToPos((Truck) vehicle.get()); final List<TruckDist> pos = newArrayList(Collections2.transform(roadModel .get().getObjectsOfType(Truck.class), new ToTruckDistFunc(reference))); checkState( pos.size() >= negotiators, "There are not enough vehicles in the system to hold a %s-party " + "negotiation, there are only %s vehicle(s).", negotiators, pos.size()); Collections.sort(pos, TRUCK_DIST_COMPARATOR); final List<Truck> trucks = newArrayList(Lists.transform(pos, TRUCK_DIST_TO_TRUCK).subList(0, negotiators)); if (!trucks.contains(vehicle.get())) { // remove the last one in the list trucks.remove(trucks.size() - 1); trucks.add((Truck) vehicle.get()); } checkArgument(trucks.contains(vehicle.get())); return trucks; }
/** * Check whether diversion after route completion but before pickup is * correctly handled depending on the configuration. */ @Test public void divertToOtherBeforePickup() { boolean success = true; try { rm.moveTo(dv1, dp1, time(7)); rm.moveTo(dv1, dp1, time(4)); assertEquals(rm.getPosition(dv1), rm.getPosition(dp1)); rm.moveTo(dv1, dp2, time(80)); } catch (final IllegalArgumentException e) { success = false; } assertEquals(allowDiversion, success); }
Point getParcelPos(RoadUser obj) { if (!containsObject(obj) && obj instanceof Parcel) { final ParcelState state = pdpModel.get().getParcelState( (Parcel) obj); checkArgument( state == ParcelState.IN_CARGO, "Can only move to parcels which are either on the map or in cargo, " + "state is %s, obj is %s.", state, obj); return ((Parcel) obj).getDeliveryLocation(); } return getPosition(obj); }
ImmutableSet.builder(); final RoadModelSnapshot snapshot = rm.getSnapshot(); for (final Vehicle v : vehicles) { final ImmutableSet<Parcel> contentsMap = time.getUnit(), rm.getSpeedUnit(), rm.getDistanceUnit(), snapshot);
/** * It is not allowed to go to a delivery location twice. */ @Test(expected = IllegalArgumentException.class) public void attemptVisitFor3rdTime() { // first pickup rm.moveTo(dv1, dp1, time(11)); rm.removeObject(dp1); // then deliver rm.moveTo(dv1, dp1, time(80)); // 3rd time is not allowed! rm.moveTo(dv1, dp1, time(80)); }
.add(realtime ? timeModelBuilder.withRealTime() : timeModelBuilder) .add( PDPRoadModel.builder( RoadModelBuilders.plane() .withMinPoint(MIN)
PDPTWTestUtil.register(rm, pm, v1, p1); final Parcel destination = rm.getObjectsOfType(Parcel.class) .iterator().next(); rm.moveTo(v1, destination, TimeLapseFactory.create(0, 1000)); assertEquals(destination, rm.getDestinationToParcel(v1)); assertEquals(ParcelState.AVAILABLE, pm.getParcelState(p1)); rm.moveTo(v1, destination, TimeLapseFactory.create(0, 1000000000)); assertEquals(rm.getPosition(destination), rm.getPosition(v1)); rm.moveTo(v1, destination, TimeLapseFactory.create(0, 1000)); assertEquals(destination, rm.getDestinationToParcel(v1)); assertEquals(ParcelState.IN_CARGO, pm.getParcelState(p1)); rm.moveTo(v1, destination, TimeLapseFactory.create(0, 1000000000)); assertEquals(destination.getDto().getDeliveryLocation(), rm.getPosition(v1)); pm.deliver(v1, p1, TimeLapseFactory.create(0, 1)); assertNull(rm.getDestinationToParcel(v1)); assertEquals(VehicleState.DELIVERING, pm.getVehicleState(v1)); final GlobalStateObject state5 = handle.convert(SolveArgs.create()
/** * It is not allowed to go to a delivery location twice. */ @Test(expected = IllegalArgumentException.class) public void attemptVisitFor3rdTime2() { // first pickup rm.moveTo(dv1, dp1, time(11)); assertTrue(rm.equalPosition(dv1, dp1)); rm.removeObject(dp1); // then deliver rm.moveTo(dv1, dp1, time(80)); assertEquals(rm.getPosition(dv1), dp1.getDeliveryLocation()); rm.moveTo(dv1, dp2, time(180)); assertTrue(rm.equalPosition(dv1, dp2)); rm.removeObject(dp2); // it is not allowed to revisit this position rm.moveTo(dv1, dp1, time(80)); }
if (destinationRoadUser instanceof Parcel) { final Parcel dp = (Parcel) destinationRoadUser; final DestType type = containsObject(dp) ? DestType.PICKUP : DestType.DELIVERY; final Point pos = getParcelPos(destinationRoadUser); if (type == DestType.DELIVERY) { checkArgument( } else { newDestinationObject = DestinationObject.create(DestType.DEPOT, getPosition(destinationRoadUser), destinationRoadUser); if (destinations.containsKey(object) && !allowDiversion) { final DestinationObject prev = destinations.get(object); final boolean atDestination = getPosition(object).equals(prev.dest()); || isAlreadyServiced(prev.type(), prev.roadUser()), "Diversion from the current destination is not allowed. " + "Prev: %s, new: %s.", destinationHistory.put(object, newDestinationObject); return delegate().moveTo(object, newDestinationObject.dest(), time, heuristic);
@Test public void twoVehiclesGoToSame() { // this is allowed rm.moveTo(dv1, dp1, time(10)); rm.moveTo(dv2, dp1, time(10)); assertEquals(rm.getPosition(dv1), rm.getPosition(dp1)); assertEquals(rm.getPosition(dv2), rm.getPosition(dp1)); pm.pickup(dv2, dp1, time(1)); assertFalse(rm.containsObject(dp1)); assertEquals(ParcelState.IN_CARGO, pm.getParcelState(dp1)); rm.moveTo(dv1, dp2, time(3)); }
Point convertToPos(Truck t) { Point p; if (t.getRoute().isEmpty() || heuristic == SelectNegotiatorsHeuristic.VEHICLE_POSITION) { p = roadModel.get().getPosition(t); } else { final Parcel firstDestination = t.getRoute().iterator().next(); if (pdpModel.get().getParcelState(firstDestination).isPickedUp()) { p = firstDestination.getDto().getDeliveryLocation(); } else { p = firstDestination.getDto().getPickupLocation(); } } return p; }
.buildDTO()); rm.addObjectAt(dp1, dp1.getDto().getPickupLocation()); pm.register(dp1); assertNull(rm.getDestinationToParcel(dv1)); rm.moveTo(dv1, dp1, time(7)); assertEquals(dp1, rm.getDestinationToParcel(dv1)); rm.moveTo(dv1, dp1, time(4)); assertEquals(dp1, rm.getDestinationToParcel(dv1)); assertNull(rm.getDestinationToParcel(dv1)); assertFalse(rm.containsObject(dp1)); assertEquals(ParcelState.PICKING_UP, pm.getParcelState(dp1)); dv1.tick(time(1)); assertEquals(ParcelState.IN_CARGO, pm.getParcelState(dp1)); rm.moveTo(dv1, dp1, time(1)); assertEquals(dp1, rm.getDestinationToParcel(dv1)); rm.moveTo(dv1, dp1, time(80)); assertEquals(dp1, rm.getDestinationToParcel(dv1)); pm.deliver(dv1, dp1, time(1)); assertNull(rm.getDestinationToParcel(dv1)); rm.moveTo(dv1, dp2, time(50)); assertEquals(dp2, rm.getDestinationToParcel(dv1));
/** * Setup an environment with three vehicles and three parcels. */ @Before public void setUp() { final DependencyProvider dp = mock(DependencyProvider.class); rm = PDPRoadModel.builder( RoadModelBuilders.plane() .withMaxSpeed(300d)) .withAllowVehicleDiversion(false) .build(dp); when(dp.get(RoadModel.class)).thenReturn(rm); pm = DefaultPDPModel.builder() .withTimeWindowPolicy(TimeWindowPolicies.TARDY_ALLOWED) .build(dp); mp = new TestModelProvider(new ArrayList<>( Arrays.<Model<?>>asList(rm, pm))); rm.registerModelProvider(mp); v1 = new TestVehicle(new Point(0, 1)); v2 = new TestVehicle(new Point(0, 2)); v3 = new TestVehicle(new Point(0, 3)); p1 = createParcel(new Point(3, 0), new Point(0, 3)); p2 = createParcel(new Point(6, 9), new Point(2, 9)); p3 = createParcel(new Point(2, 8), new Point(8, 2)); ss = rm.getSnapshot(); }
void checkVehicles(List<? extends TestVehicle> expected, ImmutableList<VehicleStateObject> states) { assertEquals(expected.size(), states.size()); for (int i = 0; i < expected.size(); i++) { final TestVehicle vehicle = expected.get(i); final VehicleDTO dto = vehicle.dto; final VehicleStateObject vs = states.get(i); assertEquals(dto.getAvailabilityTimeWindow(), vs.getDto().getAvailabilityTimeWindow()); assertEquals(dto.getCapacity(), vs.getDto().getCapacity()); assertEquals(dto.getSpeed(), vs.getDto().getSpeed(), 0); assertEquals(dto.getStartPosition(), vs.getDto().getStartPosition()); assertEquals(rm.getPosition(expected.get(i)), vs.getLocation()); final Parcel dest = rm.getDestinationToParcel(vehicle); if (dest == null) { assertFalse(vs.getDestination().isPresent()); } else { assertEquals(dest, vs.getDestination().get()); } if (pm.getVehicleState(vehicle) == VehicleState.IDLE) { assertEquals(0, vs.getRemainingServiceTime()); } else { assertEquals(pm.getVehicleActionInfo(vehicle).timeNeeded(), vs.getRemainingServiceTime()); } } }
@Test public void moveToDepot() { rm.moveTo(dv1, depot, time(1)); assertNull(rm.getDestinationToParcel(dv1)); rm.moveTo(dv1, depot, time(1)); rm.moveTo(dv1, dp1, time(1)); assertEquals(dp1, rm.getDestinationToParcel(dv1)); }
.build(dep); } else { rm = PDPRoadModel.builder( RoadModelBuilders.plane() .withMinPoint(new Point(0, 0)) rm.registerModelProvider(mp); dp3 = create(new Point(1, 0), new Point(0, 6)); for (final Parcel dp : asList(dp1, dp2, dp3)) { rm.addObjectAt(dp, dp.getDto().getPickupLocation()); pm.register(dp); rm.addObjectAt(depot, depotLocation); rm.addObjectAt(tv, tv.getDTO().getStartPosition()); pm.register(tv);
pdpRoadModel.get().isVehicleDiversionAllowed() ? null : pdpRoadModel.get().getDestinationToParcel(vehicle.get());
graphRm.register(mv1); VehicleStateObject.create( mv1.getDTO(), graphRm.getPosition(mv1), vehicleConnection, ImmutableSet.<Parcel>of(mp1), SI.METER, graphRm.getSnapshot()); assertEquals(new Point(1, 0), graphRm.getPosition(mv1)); VehicleStateObject.create( mv1.getDTO(), graphRm.getPosition(mv1), vehicleConnection, ImmutableSet.<Parcel>of(mp1), GlobalStateObject.create(availableParcels, vehicles, 1L, SI.SECOND, SI.METERS_PER_SECOND, SI.METER, graphRm.getSnapshot());
rm = PDPRoadModel.builder( RoadModelBuilders.plane() .withMaxSpeed(30d)) rm.registerModelProvider(mp);