On-demand experiments

src/main/java/com/conveyal/r5/analyst/TravelTimeComputer.java

@@ -5,7 +5,7 @@
 import com.conveyal.r5.analyst.cluster.PathWriter;
 import com.conveyal.r5.analyst.cluster.RegionalTask;
 import com.conveyal.r5.analyst.fare.InRoutingFareCalculator;
-import com.conveyal.r5.analyst.scenario.PickupWaitTimes;
+import com.conveyal.r5.analyst.scenario.ondemand.AccessService;
 import com.conveyal.r5.api.util.LegMode;
 import com.conveyal.r5.point_to_point.builder.PointToPointQuery;
 import com.conveyal.r5.profile.DominatingList;
@@ -21,16 +21,16 @@
 import com.conveyal.r5.transit.TransportNetwork;
 import com.conveyal.r5.transit.path.Path;
 import gnu.trove.map.TIntIntMap;
+import gnu.trove.map.hash.TIntIntHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.EnumSet;
 import java.util.function.IntFunction;
 import java.util.stream.Collectors;
 
-import static com.conveyal.r5.analyst.scenario.PickupWaitTimes.NO_SERVICE_HERE;
-import static com.conveyal.r5.analyst.scenario.PickupWaitTimes.NO_WAIT_ALL_STOPS;
-import static com.conveyal.r5.common.Util.isNullOrEmpty;
+import static com.conveyal.r5.analyst.scenario.ondemand.AccessService.NO_SERVICE_HERE;
+import static com.conveyal.r5.analyst.scenario.ondemand.AccessService.NO_WAIT_ALL_STOPS;
 import static com.conveyal.r5.profile.PerTargetPropagater.MM_PER_METER;
 
 /**
@@ -122,7 +122,7 @@ public OneOriginResult computeTravelTimes() {
             LOG.info("Performing street search for mode: {}", accessMode);
 
             // Look up pick-up service for an access leg.
-            PickupWaitTimes.AccessService accessService =
+            AccessService accessService =
                     network.streetLayer.getAccessService(request.fromLat, request.fromLon, accessMode);
 
             // When an on-demand mobility service is defined, it may not be available at this particular location.
@@ -179,17 +179,22 @@ public OneOriginResult computeTravelTimes() {
                 }
                 // Find access times to transit stops, keeping the minimum across all access street modes.
                 // Note that getReachedStops() returns the routing variable units, not necessarily seconds.
-                // TODO add logic here if linkedStops are specified in pickupDelay?
                 TIntIntMap travelTimesToStopsSeconds = sr.getReachedStops();
+                TIntIntMap adjustedTravelTimesToStopsSeconds = new TIntIntHashMap();
                 if (accessService != NO_WAIT_ALL_STOPS) {
-                    LOG.info("Delaying transit access times by {} seconds (to wait for {} pick-up).",
-                            accessService.waitTimeSeconds, accessMode);
-                    if (accessService.stopsReachable != null) {
-                        travelTimesToStopsSeconds.retainEntries((k, v) -> accessService.stopsReachable.contains(k));
-                    }
-                    travelTimesToStopsSeconds.transformValues(i -> i + accessService.waitTimeSeconds);
+                    LOG.info("Delaying access times to {} transit stops (to wait for {} pick-up).",
+                            accessService.waitTimesForStops.size(),
+                            accessMode);
+                    accessService.waitTimesForStops.forEachEntry((stop, wait) -> {
+                        if (travelTimesToStopsSeconds.containsKey(stop)) {
+                            adjustedTravelTimesToStopsSeconds.put(stop, wait + travelTimesToStopsSeconds.get(stop));
+                        }
+                        return true;
+                    });
+                    bestAccessOptions.update(adjustedTravelTimesToStopsSeconds, accessMode);
+                } else {
+                    bestAccessOptions.update(travelTimesToStopsSeconds, accessMode);
                 }
-               bestAccessOptions.update(travelTimesToStopsSeconds, accessMode);
             }
 
             // Calculate times to reach destinations directly by this street mode, without using transit.
@@ -225,9 +230,12 @@ public OneOriginResult computeTravelTimes() {
                 );
 
                 if (accessService != NO_WAIT_ALL_STOPS) {
-                    LOG.info("Delaying direct travel times by {} seconds (to wait for {} pick-up).",
-                            accessService.waitTimeSeconds, accessMode);
-                    if (accessService.stopsReachable != null) {
+                    if (accessService.serviceArea != null) {
+                        LOG.info("Delaying on-demand service by {} seconds (to wait for {} pick-up).",
+                                accessService.waitTimeSeconds, accessMode);
+                        pointSetTimes.incrementWithinAndClip(accessService.serviceArea, accessService.waitTimeSeconds);
+                    }
+                    else if (accessService.stops != null || !accessService.waitTimesForStops.isEmpty()) {
                         // Disallow direct travel to destination if pickupDelay zones are associated with stops.
                         pointSetTimes = PointSetTimes.allUnreached(destinations);
                     } else {

src/main/java/com/conveyal/r5/analyst/scenario/IndexedPolygonCollection.java

@@ -219,4 +219,15 @@ public ModificationPolygon getWinningPolygon (Geometry geometry) {
         return winner;
     }
 
+    public List<ModificationPolygon> getIntersectingPolygons (Geometry geometry) {
+        List<ModificationPolygon> polygons = new ArrayList<ModificationPolygon>();
+        Envelope envelope = geometry.getEnvelopeInternal();
+        List<ModificationPolygon> candidatePolygons = polygonSpatialIndex.query(envelope);
+        for (ModificationPolygon candidate : candidatePolygons) {
+            if (candidate.polygonal.intersects(geometry)) {
+                polygons.add(candidate);
+            }
+        }
+        return polygons;
+    }
 }

src/main/java/com/conveyal/r5/analyst/scenario/PickupDelay.java

@@ -1,5 +1,6 @@
 package com.conveyal.r5.analyst.scenario;
 
+import com.conveyal.r5.analyst.scenario.ondemand.EgressService;
 import com.conveyal.r5.profile.StreetMode;
 import com.conveyal.r5.transit.TransportNetwork;
 import com.conveyal.r5.util.ExceptionUtils;
@@ -33,18 +34,10 @@ public class PickupDelay extends Modification {
     /**
      * The identifier of the polygon layer containing the on-demand pick-up zones.
      * This set of polygons represents areas where an on-demand mobility service will pick up passengers, with
-     * associated wait times to be picked up. Overlapping zones are not yet supported, only one "winning" zone will
-     * be chosen using the priority values.
+     * associated wait times to be picked up.
      */
     public String zonePolygons;
 
-    /**
-     * The identifier of the polygon layer containing the stops associated with the zones, if any.
-     * Having two different polygon files raises questions about whether the attribute names can be set separately,
-     * and how we would factor out that aspect of the polygon loading code.
-     */
-    // public String stopPolygons;
-
     /**
      * The name of the attribute (floating-point) within the polygon layer that contains the pick-up wait time
      * (in minutes). Negative waiting times mean the area is not served at all.
@@ -65,9 +58,17 @@ public class PickupDelay extends Modification {
     public String idAttribute = "id";
 
     /**
-     * A JSON map from polygon IDs to lists of polygon IDs. If any stop_id is specified for a polygon, service is
-     * only allowed between the polygon and the stops (i.e. no direct trips). If no stop_ids are specified,
-     * passengers boarding an on-demand service in a pick-up zone should be able to alight anywhere.
+     * A JSON map from polygon IDs to lists of polygon IDs, representing origin zones and allowable destination zones
+     * for direct legs. For example, "a":["b","c"] allows passengers to travel from zone a to destinations in zones
+     * b and c. For now, this does not enable use of stops in zones b and c for onward travel, so in most cases,
+     * these zones should be explicitly repeated in stopsForZone.
+     */
+    public Map<String, Set<String>> destinationsForZone;
+
+    /**
+     * A JSON map from polygon IDs to lists of polygon IDs, representing origin zones and allowable boarding stops
+     * for access legs. For example "a":["d","e"] allows passengers to travel from zone a to transit stops in zones d
+     * and e.
      */
     public Map<String, Set<String>> stopsForZone;
 
@@ -88,12 +89,6 @@ public class PickupDelay extends Modification {
     /** The result of resolving this modification against the TransportNetwork. */
     private transient PickupWaitTimes pickupWaitTimes;
 
-    /**
-     * These polygons contain the stops served by the zones. Wait times are also loaded for these polygons and will be
-     * used on the egress end of the itinerary.
-     */
-    //private transient IndexedPolygonCollection stopPolygons;
-
     // Implementations of methods for the Modification interface
 
     @Override
@@ -113,58 +108,71 @@ public boolean resolve (TransportNetwork network) {
             // Collect any errors from the IndexedPolygonCollection construction, so they can be seen in the UI.
             addErrors(polygons.getErrors());
             // Handle pickup service to stop mapping if supplied in the modification JSON.
-            if (stopsForZone == null) {
-                this.pickupWaitTimes = new PickupWaitTimes(polygons, null, Collections.emptySet(), this.streetMode);
+            if (stopsForZone == null && destinationsForZone == null) {
+                this.pickupWaitTimes = new PickupWaitTimes(
+                        polygons,
+                        null,
+                        null,
+                        Collections.emptySet(),
+                        this.streetMode
+                );
             } else {
-                // Iterate over all zone-stop mappings and resolve them against the network.
+                // Iterate over all zone-zone mappings and resolve them against the network.
                 // Because they are used in lambda functions, these variables must be final and non-null.
                 // That is why there's a separate PickupWaitTimes constructor call above with a null parameter.
                 final Map<ModificationPolygon, TIntSet> stopNumbersForZonePolygon = new HashMap<>();
-                final Map<ModificationPolygon, PickupWaitTimes.EgressService> egressServices = new HashMap<>();
-                if (stopsForZone.isEmpty()) {
-                    addError("If stopsForZone is specified, it must be non-empty.");
-                }
-                stopsForZone.forEach((zonePolygonId, stopPolygonIds) -> {
-                    ModificationPolygon zonePolygon = polygons.getById(zonePolygonId);
-                    if (zonePolygon == null) {
-                        addError("Could not find zone polygon with ID: " + zonePolygonId);
-                    }
-                    TIntSet stopNumbers = stopNumbersForZonePolygon.get(zonePolygon);
-                    if (stopNumbers == null) {
-                        stopNumbers = new TIntHashSet();
-                        stopNumbersForZonePolygon.put(zonePolygon, stopNumbers);
-                    }
-                    for (String stopPolygonId : stopPolygonIds) {
-                        ModificationPolygon stopPolygon = polygons.getById(stopPolygonId);
-                        if (stopPolygon == null) {
-                            addError("Could not find stop polygon with ID: " + stopPolygonId);
+                final Map<ModificationPolygon, Geometry> destinationsForZonePolygon = new HashMap<>();
+                final Map<ModificationPolygon, EgressService> egressServices = new HashMap<>();
+                if (destinationsForZone != null) {
+                    destinationsForZone.forEach((zonePolygonId, destinationPolygonIds) -> {
+                        ModificationPolygon zonePolygon = tryToGetPolygon(polygons, zonePolygonId, "zone");
+                        for (String id : destinationPolygonIds) {
+                            ModificationPolygon destinationPolygon = tryToGetPolygon(polygons, id, "destination");
+                            Geometry polygon = destinationsForZonePolygon.get(zonePolygon) == null ?
+                                    destinationPolygon.polygonal :
+                                    destinationsForZonePolygon.get(zonePolygon).union(destinationPolygon.polygonal);
+                            destinationsForZonePolygon.put(zonePolygon, polygon);
                         }
-                        TIntSet stops = network.transitLayer.findStopsInGeometry(stopPolygon.polygonal);
-                        if (stops.isEmpty()) {
-                            addError("Stop polygon did not contain any stops: " + stopPolygonId);
+                    });
+                }
+                if (stopsForZone != null) {
+                    stopsForZone.forEach((zonePolygonId, stopPolygonIds) -> {
+                        ModificationPolygon zonePolygon = tryToGetPolygon(polygons, zonePolygonId, "zone");
+                        TIntSet stopNumbers = stopNumbersForZonePolygon.get(zonePolygon);
+                        if (stopNumbers == null) {
+                            stopNumbers = new TIntHashSet();
+                            stopNumbersForZonePolygon.put(zonePolygon, stopNumbers);
                         }
-                        stopNumbers.addAll(stops);
-                        // Derive egress services from this pair of polygons
-                        double egressWaitMinutes = stopPolygon.data;
-                        if (egressWaitMinutes >= 0) {
-                            // This stop polygon can be used on the egress end of a trip.
-                            int egressWaitSeconds = (int) (egressWaitMinutes * 60);
-                            Geometry serviceArea = zonePolygon.polygonal;
-                            PickupWaitTimes.EgressService egressService = egressServices.get(stopPolygon);
-                            if (egressService != null) {
-                                // Merge service are with any other service polygons associated with this stop polygon.
-                                serviceArea = serviceArea.union(egressService.serviceArea);
+                        for (String stopPolygonId : stopPolygonIds) {
+                            ModificationPolygon stopPolygon = tryToGetPolygon(polygons, stopPolygonId, "stop");
+                            TIntSet stops = network.transitLayer.findStopsInGeometry(stopPolygon.polygonal);
+                            if (stops.isEmpty()) {
+                                errors.add("Stop polygon did not contain any stops: " + stopPolygonId);
+                            }
+                            stopNumbers.addAll(stops);
+                            // Derive egress services from this pair of polygons
+                            double egressWaitMinutes = stopPolygon.data;
+                            if (egressWaitMinutes >= 0) {
+                                // This stop polygon can be used on the egress end of a trip.
+                                int egressWaitSeconds = (int) (egressWaitMinutes * 60);
+                                Geometry serviceArea = zonePolygon.polygonal;
+                                EgressService egressService = egressServices.get(stopPolygon);
+                                if (egressService != null) {
+                                    // Merge service area with any other service polygons associated with this stop polygon.
+                                    serviceArea = serviceArea.union(egressService.serviceArea);
+                                }
+                                egressService = new EgressService(egressWaitSeconds, stops, serviceArea);
+                                egressServices.put(stopPolygon, egressService);
                             }
-                            egressService = new PickupWaitTimes.EgressService(egressWaitSeconds, stops, serviceArea);
-                            egressServices.put(stopPolygon, egressService);
                         }
-                    }
-                });
+
+                    });
+                }
                 // TODO filter out polygons that aren't keys in stopsForZone using new IndexedPolygonCollection constructor
-                // egress wait times for stop numbers
                 this.pickupWaitTimes = new PickupWaitTimes(
                         polygons,
                         stopNumbersForZonePolygon,
+                        destinationsForZonePolygon,
                         egressServices.values(),
                         this.streetMode
                 );
@@ -176,6 +184,14 @@ public boolean resolve (TransportNetwork network) {
         return hasErrors();
     }
 
+    private ModificationPolygon tryToGetPolygon (IndexedPolygonCollection polygons, String id, String label) {
+        ModificationPolygon polygon = polygons.getById(id);
+        if (polygon == null) {
+            errors.add("Could not find " + label + " polygon with ID: " + id);
+        }
+        return polygon;
+    }
+
     @Override
     public boolean apply (TransportNetwork network) {
         // network.streetLayer is already a protective copy made by method Scenario.applyToTransportNetwork.