private Double getLastTransport(TourActivity activity, VehicleRoute route, StateId id) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return 0.;
if (activity instanceof End) return stateManager.getRouteState(route, id, Double.class);
verifyThatRouteContainsAct(activity, route);
return stateManager.getActivityState(activity, id, Double.class);
}
@Override
public void visit(TourActivity activity) {
stateManager.putActivityState(activity, last_transport_distance_id, distance(activity));
stateManager.putActivityState(activity, last_transport_time_id, transportTime(activity));
stateManager.putActivityState(activity, last_transport_cost_id, transportCost(activity));
prevAct = activity;
prevActDeparture = activity.getEndTime();
}
@Override
public void finish() {
// shipment
// pickups without deliveries
for (TourActivity act : openShipments.values()) {
stateManager.putActivityState(act, shipment_id, true);
shipmentConstraintOnRouteViolated = true;
}
stateManager.putRouteState(route, shipment_id, shipmentConstraintOnRouteViolated);
// backhaul
stateManager.putRouteState(route, backhaul_id, backhaulConstraintOnRouteViolated);
}
@Override
public void finish() {
sum_transport_time += route.getEnd().getArrTime() - prevActDeparture;
sum_too_late +=
Math.max(
0,
route.getEnd().getArrTime()
- route.getEnd().getTheoreticalLatestOperationStartTime());
stateManager.putRouteState(route, transport_time_id, sum_transport_time);
stateManager.putRouteState(route, waiting_time_id, sum_waiting_time);
stateManager.putRouteState(route, service_time_id, sum_service_time);
stateManager.putRouteState(route, too_late_id, sum_too_late);
}
@Override
public void visit(TourActivity activity) {
// waiting time & toolate
double waitAtAct = 0.;
double tooLate = 0.;
if (activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)) {
waitAtAct =
Math.max(
0, activity.getTheoreticalEarliestOperationStartTime() - activity.getArrTime());
tooLate =
Math.max(0, activity.getArrTime() - activity.getTheoreticalLatestOperationStartTime());
}
sum_waiting_time += waitAtAct;
sum_too_late += tooLate;
// transport time
double transportTime = activity.getArrTime() - prevActDeparture;
sum_transport_time += transportTime;
prevActDeparture = activity.getEndTime();
// service time
sum_service_time +=
activityCosts.getActivityDuration(
activity, activity.getArrTime(), route.getDriver(), route.getVehicle());
stateManager.putActivityState(activity, transport_time_id, sum_transport_time);
}
@Override
public void finish() {
double distance =
distanceCalculator.getDistance(prevAct.getLocation(), route.getEnd().getLocation());
sum_distance += distance;
stateManager.putRouteState(route, distance_id, sum_distance);
}
/**
* @param activity at which is distance of the current route is measured
* @return distance at activity
*/
public Double getDistanceAtActivity(TourActivity activity, VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return 0.;
if (activity instanceof End) return getDistance(route);
verifyThatRouteContainsAct(activity, route);
return stateManager.getActivityState(activity, distance_id, Double.class);
}
/**
* @param activity to check skill constraint
* @param route that must contain specified activity
* @return true if vehicle does not have the skills to conduct specified activity, false
* otherwise. Returns null if specified route or activity is null or if route does not contain
* specified activity or if skill state connot be found. If specified activity is Start or
* End, it returns false.
*/
public Boolean hasSkillConstraintViolationAtActivity(TourActivity activity, VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return false;
if (activity instanceof End) return false;
verifyThatRouteContainsAct(activity, route);
return stateManager.getActivityState(activity, skill_id, Boolean.class);
}
/**
* @param activity to get the load from (after activity)
* @return load right after the specified activity. If act is Start, it returns the load
* atBeginning of the specified route. If act is End, it returns the load atEnd of specified
* route. Returns null if no load can be found.
*/
public Capacity getLoadRightAfterActivity(TourActivity activity, VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return getLoadAtBeginning(route);
if (activity instanceof End) return getLoadAtEnd(route);
verifyThatRouteContainsAct(activity, route);
return stateManager.getActivityState(activity, InternalStates.LOAD, Capacity.class);
}
/**
* @param activity to get the variable transport costs from
* @param route where the activity should be part of
* @return variable transport costs at activity, i.e. sum of transport costs from start of route
* to the specified activity If activity is start, it returns 0.. If it is end, it returns
* .getVariableTransportCosts(route).
*/
public Double getVariableTransportCostsAtActivity(TourActivity activity, VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return 0.;
if (activity instanceof End) return getVariableTransportCosts(route);
verifyThatRouteContainsAct(activity, route);
return stateManager.getActivityState(activity, InternalStates.COSTS, Double.class);
}
@Override
public void visit(TourActivity activity) {
double distance =
distanceCalculator.getDistance(prevAct.getLocation(), activity.getLocation());
sum_distance += distance;
stateManager.putActivityState(activity, distance_id, sum_distance);
prevAct = activity;
}
@Override
public void visit(TourActivity activity) {
// shipment
if (activity instanceof PickupShipment) {
openShipments.put(((PickupShipment) activity).getJob().getId(), (PickupShipment) activity);
} else if (activity instanceof DeliverShipment) {
String jobId = ((DeliverShipment) activity).getJob().getId();
if (!openShipments.containsKey(jobId)) {
// deliverShipment without pickupShipment
stateManager.putActivityState(activity, shipment_id, true);
shipmentConstraintOnRouteViolated = true;
} else {
PickupShipment removed = openShipments.remove(jobId);
stateManager.putActivityState(removed, shipment_id, false);
stateManager.putActivityState(activity, shipment_id, false);
}
} else stateManager.putActivityState(activity, shipment_id, false);
// backhaul
if (activity instanceof DeliverService && pickupOccured) {
stateManager.putActivityState(activity, backhaul_id, true);
backhaulConstraintOnRouteViolated = true;
} else {
if (activity instanceof PickupService
|| activity instanceof ServiceActivity
|| activity instanceof PickupShipment) {
pickupOccured = true;
stateManager.putActivityState(activity, backhaul_id, false);
} else stateManager.putActivityState(activity, backhaul_id, false);
}
}
/**
* @param activity to get the load from (before activity)
* @return load just before the specified activity. If act is Start, it returns the load
* atBeginning of the specified route. If act is End, it returns the load atEnd of specified
* route.
*/
public Capacity getLoadJustBeforeActivity(TourActivity activity, VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
if (activity == null) throw new IllegalArgumentException("activity is missing.");
if (activity instanceof Start) return getLoadAtBeginning(route);
if (activity instanceof End) return getLoadAtEnd(route);
verifyThatRouteContainsAct(activity, route);
Capacity afterAct =
stateManager.getActivityState(activity, InternalStates.LOAD, Capacity.class);
if (afterAct != null && activity.getSize() != null) {
return Capacity.subtract(afterAct, activity.getSize());
} else if (afterAct != null) return afterAct;
else return null;
}
private LoadAndActivityCounter(StateManager stateManager) {
this.stateManager = stateManager;
pickup_count_id = stateManager.createStateId(PICKUP_COUNT);
delivery_count_id = stateManager.createStateId(DELIVERY_COUNT);
load_picked_id = stateManager.createStateId(LOAD_PICKED);
load_delivered_id = stateManager.createStateId(LOAD_DELIVERED);
pickup_at_beginning_count_id = stateManager.createStateId(PICKUP_COUNT_AT_BEGINNING);
delivery_at_end_count_id = stateManager.createStateId(DELIVERY_COUNT_AT_END);
}
@Override
public void finish() {
stateManager.putRouteState(route, pickup_count_id, pickupCounter);
stateManager.putRouteState(route, delivery_count_id, deliveryCounter);
stateManager.putRouteState(route, load_picked_id, pickedUp);
stateManager.putRouteState(route, load_delivered_id, delivered);
stateManager.putRouteState(route, pickup_at_beginning_count_id, pickupAtBeginningCounter);
stateManager.putRouteState(route, delivery_at_end_count_id, deliverAtEndCounter);
}
@Override
public void visit(TourActivity activity) {
boolean violatedAtActivity = false;
if (activity instanceof TourActivity.JobActivity) {
Set<String> requiredForActivity =
((TourActivity.JobActivity) activity).getJob().getRequiredSkills().values();
for (String skill : requiredForActivity) {
if (!route.getVehicle().getSkills().containsSkill(skill)) {
violatedAtActivity = true;
skillConstraintViolatedOnRoute = true;
}
}
}
stateManager.putActivityState(activity, skill_id, violatedAtActivity);
}
/**
* @param route to get the number of pickups at beginning from
* @return number of pickups at beginning
*/
public Integer getNumberOfPickupsAtBeginning(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(
route, stateManager.createStateId(PICKUP_COUNT_AT_BEGINNING), Integer.class);
}
private void refreshStates() {
stateManager.clear();
stateManager.informInsertionStarts(solution.getRoutes(), null);
clearSolutionIndicators();
recalculateSolutionIndicators();
}
/**
* @param route to get delivered load from
* @return delivered laod (without load at end)
*/
public Capacity getLoadDelivered(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(
route, stateManager.createStateId(LOAD_DELIVERED), Capacity.class);
}
/**
* @param route to get the time window violation from
* @return time violation of route, i.e. sum of individual activity time window violations.
*/
public Double getTimeWindowViolation(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, too_late_id, Double.class);
}
@Override
public void finish() {
stateManager.putRouteState(route, last_transport_distance_id, distance(route.getEnd()));
stateManager.putRouteState(route, last_transport_time_id, transportTime(route.getEnd()));
stateManager.putRouteState(route, last_transport_cost_id, transportCost(route.getEnd()));
}
/**
* @param route to get number of deliveries from
* @return number of deliveries delivered on specified route (without load at end)
*/
public Integer getNumberOfDeliveries(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(
route, stateManager.createStateId(DELIVERY_COUNT), Integer.class);
}
/**
* Returns true, if shipment constraint is violated. Two activities are associated to a shipment:
* pickupShipment and deliverShipment. If both shipments are not in the same route OR
* deliverShipment occurs before pickupShipment then the shipment constraint is violated.
*
* @param route to check the shipment constraint.
* @return true if violated, false otherwise. Null if no state can be found or specified route is
* null.
*/
public Boolean hasShipmentConstraintViolation(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, shipment_id, Boolean.class);
}
/**
* @param route to get max load from
* @return max load of specified route, i.e. for each capacity dimension the max value.
*/
public Capacity getMaxLoad(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, InternalStates.MAXLOAD, Capacity.class);
}
/**
* @param route to get the load at beginning from
* @return load at start location of specified route
*/
public Capacity getLoadAtBeginning(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, InternalStates.LOAD_AT_BEGINNING, Capacity.class);
}
@Override
public void finish() {
stateManager.putRouteState(route, skill_id, skillConstraintViolatedOnRoute);
}
private void initialise() {
this.stateManager = new StateManager(vrp);
this.stateManager.updateTimeWindowStates();
this.stateManager.updateLoadStates();
this.stateManager.updateSkillStates();
activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
this.stateManager.addStateUpdater(
new UpdateActivityTimes(vrp.getTransportCosts(), activityPolicy, vrp.getActivityCosts()));
this.stateManager.addStateUpdater(
new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
waiting_time_id = stateManager.createStateId("waiting-time");
transport_time_id = stateManager.createStateId("transport-time");
service_time_id = stateManager.createStateId("service-time");
distance_id = stateManager.createStateId("distance");
too_late_id = stateManager.createStateId("too-late");
shipment_id = stateManager.createStateId("shipment");
backhaul_id = stateManager.createStateId("backhaul");
skill_id = stateManager.createStateId("skills-violated");
last_transport_cost_id = stateManager.createStateId("last-transport-cost");
last_transport_distance_id = stateManager.createStateId("last-transport-distance");
last_transport_time_id = stateManager.createStateId("last-transport-time");
stateManager.addStateUpdater(
new SumUpActivityTimes(
waiting_time_id,
transport_time_id,
service_time_id,
too_late_id,
stateManager,
activityPolicy,
vrp.getActivityCosts()));
stateManager.addStateUpdater(
new DistanceUpdater(distance_id, stateManager, distanceCalculator));
stateManager.addStateUpdater(
new BackhaulAndShipmentUpdater(backhaul_id, shipment_id, stateManager));
stateManager.addStateUpdater(new SkillUpdater(stateManager, skill_id));
stateManager.addStateUpdater(new LoadAndActivityCounter(stateManager));
stateManager.addStateUpdater(
new LastTransportUpdater(
stateManager,
vrp.getTransportCosts(),
distanceCalculator,
last_transport_distance_id,
last_transport_time_id,
last_transport_cost_id));
}
/**
* @param route to get the total waiting time from
* @return total waiting time of this route, i.e. sum of waiting times at activities. Returns null
* if no waiting time value exists for the specified route
*/
public Double getWaitingTime(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, waiting_time_id, Double.class);
}
/**
* @param route to get the transport costs from
* @return total variable transport costs of route, i.e. sum of transport costs specified by
* vrp.getTransportCosts().getTransportCost(fromId,toId,...)
*/
public Double getVariableTransportCosts(VehicleRoute route) {
if (route == null) throw new IllegalArgumentException("route is missing.");
return stateManager.getRouteState(route, InternalStates.COSTS, Double.class);
}