Merge pull request #446 from ipeaGIT/arrive-by-search-java

added arrival_travel_time_matrix.R

Author: rafapereirabr

README.md

@@ -71,24 +71,30 @@ The package has seven **fundamental functions**:
 
 3. `travel_time_matrix()`
    * Fast function that returns a simple `data.table` with travel time estimates
-   between one or multiple origin destination pairs.
+   between one or multiple origin destination pairs considering departure time.
 
-4. `expanded_travel_time_matrix()`
+4. `arrival_travel_time_matrix()`
+   * Calculates travel time matrices between origin destination pairs considering 
+   a time of arrival. The output includes additional information such as the 
+   routes used and total time disaggregated by access, waiting, in-vehicle and 
+   transfer times.
+
+5. `expanded_travel_time_matrix()`
    * Calculates travel time matrices between origin destination pairs with 
    additional information such as routes used and total time disaggregated by access, 
    waiting, in-vehicle and transfer times.
 
-5. `detailed_itineraries()`
+6. `detailed_itineraries()`
    * Returns a `data.frame sf LINESTRINGs` with one or multiple alternative routes
    between one or multiple origin destination pairs. The data output brings 
    detailed information on transport mode, travel time, walk distance etc for 
    each trip segment.
 
-6. `pareto_frontier()`
+7. `pareto_frontier()`
    * Returns a `data.table` with the travel time and monetary cost of multiple
    route alternatives for specified origin-destination pairs.
 
-7. `isochrone()`
+8. `isochrone()`
    * Returns a `A ⁠POLYGON  "sf" "data.frame"` showing the area that can be reached from an origin point at a given travel time limit.
 
 obs. Most of these functions also allow users to account for monetary travel costs 

java-r5rcore/src/org/ipea/r5r/Process/TravelTimeMatrixComputer.java

@@ -6,6 +6,7 @@
 import com.conveyal.r5.analyst.cluster.PathResult;
 import com.conveyal.r5.analyst.cluster.RegionalTask;
 import com.conveyal.r5.analyst.cluster.TravelTimeResult;
+import com.conveyal.r5.api.util.SearchType;
 import com.conveyal.r5.transit.TransportNetwork;
 import com.conveyal.r5.transit.path.RouteSequence;
 import com.google.common.collect.ArrayListMultimap;
@@ -17,7 +18,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.reflect.Field;
 import java.text.ParseException;
 import java.util.*;
 import java.util.concurrent.ForkJoinPool;
@@ -90,6 +90,8 @@ public void unreachable() {
 
     private final CsvResultOptions csvOptions;
 
+    private int monteCarloDrawsPerMinute;
+
     @Override
     protected boolean isOneToOne() {
         return false;
@@ -150,76 +152,127 @@ private void populateExpandedResults(OneOriginResult travelTimeResults, RDataFra
         // extract travel paths, if required
         Multimap<Integer, PathBreakdown>[] pathBreakdown = extractPathResults(travelTimeResults.paths, travelTimeResults.travelTimes);
 
-        for (int destination = 0; destination < travelTimeResults.travelTimes.nPoints; destination++) {
-            // fill travel details for destination
-            populateTravelTimesBreakdown(travelTimesTable, pathBreakdown, destination);
+        // set expected monteCarloDrawsPerMinute to later use to count if every path was accounted for in routing
+        monteCarloDrawsPerMinute = transportNetwork.transitLayer.hasFrequencies
+                ? routingProperties.numberOfMonteCarloDraws / routingProperties.timeWindowSize
+                : 1;
+
+
+        if (routingProperties.searchType == SearchType.ARRIVE_BY) {
+            for (int destination = 0; destination < travelTimeResults.travelTimes.nPoints; destination++) {
+                // fill travel details for destination
+                filterLatestBeforeArrivalTime(travelTimesTable, pathBreakdown, destination);
+            }
+        } else {
+            for (int destination = 0; destination < travelTimeResults.travelTimes.nPoints; destination++) {
+                // fill travel details for destination
+                populateTravelTimesBreakdown(travelTimesTable, pathBreakdown, destination);
+            }
         }
     }
 
-    private Multimap<Integer, PathBreakdown>[] extractPathResults(PathResult paths, TravelTimeResult travelTimes) {
-        try {
-            // Create Field object
-            Field privateField = PathResult.class.getDeclaredField("iterationsForPathTemplates");
-            // Set the accessibility as true
-            privateField.setAccessible(true);
-            // Store the value of private field in variable
-            Multimap<RouteSequence, PathResult.Iteration>[] iterationMaps = (Multimap<RouteSequence, PathResult.Iteration>[])privateField.get(paths);
-
-            Multimap<Integer, PathBreakdown>[] pathResults = new Multimap[nDestinations];
-
-            for (int d = 0; d < nDestinations; d++) {
-                pathResults[d] = ArrayListMultimap.create();
-
-                Multimap<RouteSequence, PathResult.Iteration> iterationMap = iterationMaps[d];
-                if (iterationMap != null) {
-
-                    for (RouteSequence routeSequence : iterationMap.keySet()) {
-                        Collection<PathResult.Iteration> iterations = iterationMap.get(routeSequence);
-                        int nIterations = iterations.size();
-                        checkState(nIterations > 0, "A path was stored without any iterations");
-
-                        // extract the route id's
-                        String[] path = routeSequence.detailsWithGtfsIds(this.transportNetwork.transitLayer, csvOptions);
-
-                        for (PathResult.Iteration iteration : iterations) {
-                            PathBreakdown breakdown = new PathBreakdown();
-                            breakdown.departureTime = Utils.getTimeFromSeconds(iteration.departureTime);
-                            breakdown.accessTime = routeSequence.stopSequence.access == null ? 0 : routeSequence.stopSequence.access.time / 60.0f;
-                            breakdown.waitTime = iteration.waitTimes.sum() / 60.0f;
-                            breakdown.rideTime = routeSequence.stopSequence.rideTimesSeconds == null ? 0 : routeSequence.stopSequence.rideTimesSeconds.sum() / 60.0f;
-                            breakdown.transferTime = routeSequence.stopSequence.transferTime(iteration) / 60f;
-                            breakdown.egressTime = routeSequence.stopSequence.egress == null ? 0 : routeSequence.stopSequence.egress.time / 60.0f;
-                            breakdown.totalTime = iteration.totalTime / 60.0f;
-
-                            breakdown.routes = path[0];
-                            breakdown.nRides = routeSequence.stopSequence.rideTimesSeconds == null ? 0 : routeSequence.stopSequence.rideTimesSeconds.size();
-
-                            if (iteration.departureTime == 0) {
-                                breakdown.departureTime = "";
-                                breakdown.routes = this.directModes.toString();
-                            }
-
-                            pathResults[d].put(iteration.departureTime, breakdown);
+    private void filterLatestBeforeArrivalTime(RDataFrame travelTimesTable, Multimap<Integer, PathBreakdown>[] pathBreakdown, int destination) {
+        if (this.routingProperties.expandedTravelTimes & pathBreakdown != null) {
+            if (!pathBreakdown[destination].isEmpty()) {
+                // for this destination return the latest departing trip that still arrives before the arrival time
+                int desiredArrivalTime = secondsFromMidnight + maxTripDuration * 60; // convert trip duration to seconds
+
+                for (int departureTime = secondsFromMidnight + (routingProperties.timeWindowSize - 1) * 60;
+                     departureTime >= secondsFromMidnight;
+                     departureTime -= 60) {
+                    Collection<PathBreakdown> pbs = pathBreakdown[destination].get(departureTime);
+
+                    int monteCarloDrawsForPath = 0;
+                    for (PathBreakdown path : pbs) {
+                        int arrivalTime = departureTime + (int) (path.getTotalTime() * 60);
+                        monteCarloDrawsForPath++;
+                        if (arrivalTime <= desiredArrivalTime) {
+                            addPathToDataframe(travelTimesTable, destination, monteCarloDrawsForPath, path);
+                            return; // only return the first trip per destination that arrives before the desiredArrivalTime cutoff
+                            // since we are searching in descending order of departure times it will be the lastest
+                            // departure arriving before our desired time
                         }
                     }
-                } else {
-                    // if iteration map for this destination is null, add possible direct route if shorter than max trip duration
-                    if (travelTimes.getValues()[0][d] <= this.maxTripDuration) {
-                        PathBreakdown breakdown = new PathBreakdown();
-                        breakdown.departureTime = "";
-                        breakdown.routes = this.directModes.toString();
-                        breakdown.totalTime = travelTimes.getValues()[0][d];
-                        pathResults[d].put(0, breakdown);
+
+                    // if there are less routes than expected check direct paths
+                    if (monteCarloDrawsForPath < monteCarloDrawsPerMinute) {
+                        Collection<PathBreakdown> directPaths = pathBreakdown[destination].get(0);
+
+                        PathBreakdown directPath;
+                        if (!directPaths.isEmpty()) {
+                            directPath = directPaths.iterator().next();
+                        } else {
+                            return; // if path is unreachable there is no point seeing if it arrives in time
+                        }
+
+                        monteCarloDrawsForPath = 1; // artificial "first draw" for direct path
+                        int arrivalTime = departureTime + (int) (directPath.getTotalTime() * 60);
+
+                        if (arrivalTime <= desiredArrivalTime) {
+                            directPath.departureTime = Utils.getTimeFromSeconds(departureTime);
+                            addPathToDataframe(travelTimesTable, destination, monteCarloDrawsForPath, directPath);
+                            return; // only return the first trip per destination that arrives before the desiredArrivalTime cutoff
+                            // since we are searching in descending order of departure times it will be the lastest
+                            // departure arriving before our desired time
+                        }
                     }
                 }
             }
+        }
+    }
 
-            return pathResults;
+    private Multimap<Integer, PathBreakdown>[] extractPathResults(PathResult paths, TravelTimeResult travelTimes) {
+        Multimap<Integer, PathBreakdown>[] pathResults = new Multimap[nDestinations];
 
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            e.printStackTrace();
-            return null;
+        for (int d = 0; d < nDestinations; d++) {
+            pathResults[d] = ArrayListMultimap.create();
+
+            Multimap<RouteSequence, PathResult.Iteration> iterationMap = paths.iterationsForPathTemplates[d];
+            if (iterationMap != null) {
+
+                for (RouteSequence routeSequence : iterationMap.keySet()) {
+                    Collection<PathResult.Iteration> iterations = iterationMap.get(routeSequence);
+                    int nIterations = iterations.size();
+                    checkState(nIterations > 0, "A path was stored without any iterations");
+
+                    // extract the route id's
+                    String[] path = routeSequence.detailsWithGtfsIds(this.transportNetwork.transitLayer, csvOptions);
+
+                    for (PathResult.Iteration iteration : iterations) {
+                        PathBreakdown breakdown = new PathBreakdown();
+                        breakdown.departureTime = Utils.getTimeFromSeconds(iteration.departureTime);
+                        breakdown.accessTime = routeSequence.stopSequence.access == null ? 0 : routeSequence.stopSequence.access.time / 60.0f;
+                        breakdown.waitTime = iteration.waitTimes.sum() / 60.0f;
+                        breakdown.rideTime = routeSequence.stopSequence.rideTimesSeconds == null ? 0 : routeSequence.stopSequence.rideTimesSeconds.sum() / 60.0f;
+                        breakdown.transferTime = routeSequence.stopSequence.transferTime(iteration) / 60f;
+                        breakdown.egressTime = routeSequence.stopSequence.egress == null ? 0 : routeSequence.stopSequence.egress.time / 60.0f;
+                        breakdown.totalTime = iteration.totalTime / 60.0f;
+
+                        breakdown.routes = path[0];
+                        breakdown.nRides = routeSequence.stopSequence.rideTimesSeconds == null ? 0 : routeSequence.stopSequence.rideTimesSeconds.size();
+
+                        if (iteration.departureTime == 0) {
+                            breakdown.departureTime = "";
+                            breakdown.routes = this.directModes.toString();
+                        }
+
+                        pathResults[d].put(iteration.departureTime, breakdown);
+                    }
+                }
+            } else {
+                // if iteration map for this destination is null, add possible direct route if shorter than max trip duration
+                if (travelTimes.getValues()[0][d] <= this.maxTripDuration) {
+                    PathBreakdown breakdown = new PathBreakdown();
+                    breakdown.departureTime = "";
+                    breakdown.routes = this.directModes.toString();
+                    breakdown.totalTime = travelTimes.getValues()[0][d];
+                    pathResults[d].put(0, breakdown);
+                }
+            }
         }
+
+        return pathResults;
+
     }
 
     private void populateTravelTimesBreakdown(RDataFrame travelTimesTable, Multimap<Integer, PathBreakdown>[] pathBreakdown, int destination) {
@@ -238,13 +291,7 @@ private void populateTravelTimesBreakdown(RDataFrame travelTimesTable, Multimap<
                         addPathToDataframe(travelTimesTable, destination, monteCarloDrawsForPath, path);
                     }
 
-                    int monteCarloDrawsPerMinute;
-                    if (this.transportNetwork.transitLayer.hasFrequencies) {
-                        monteCarloDrawsPerMinute = routingProperties.numberOfMonteCarloDraws / routingProperties.timeWindowSize;
-                    } else {
-                        monteCarloDrawsPerMinute = 1;
-                    }
-
+                    // if there are less routes than expected check direct paths
                     if (monteCarloDrawsForPath < monteCarloDrawsPerMinute) {
                         Collection<PathBreakdown> directPaths = pathBreakdown[destination].get(0);
 

java-r5rcore/src/org/ipea/r5r/R5RCore.java

@@ -5,6 +5,7 @@
 import com.conveyal.r5.analyst.Grid;
 import com.conveyal.r5.analyst.cluster.PathResult;
 import com.conveyal.r5.analyst.decay.*;
+import com.conveyal.r5.api.util.SearchType;
 import com.conveyal.r5.transit.TransportNetwork;
 import com.fasterxml.jackson.core.JsonProcessingException;
 
@@ -118,6 +119,10 @@ public void setExpandedTravelTimes(boolean expandedTravelTimes) {
         this.routingProperties.expandedTravelTimes = expandedTravelTimes;
     }
 
+    public void setSearchType(String searchType) {
+        this.routingProperties.searchType = SearchType.valueOf(searchType);
+    }
+
     public void setTravelTimesBreakdown(boolean detailedTravelTimes) {
         this.routingProperties.travelTimesBreakdown = detailedTravelTimes;
     }

java-r5rcore/src/org/ipea/r5r/RoutingProperties.java

@@ -2,6 +2,7 @@
 
 import com.conveyal.r5.analyst.cluster.PathResult;
 import com.conveyal.r5.analyst.fare.*;
+import com.conveyal.r5.api.util.SearchType;
 import com.conveyal.r5.transit.TransitLayer;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.core.JsonProcessingException;
@@ -40,6 +41,7 @@ public class RoutingProperties {
     public float[] fareCutoffs = DEFAULT_FARE_CUTOFFS;
     public InRoutingFareCalculator fareCalculator = null;
     public TransitLayer transitLayer = null;
+    public SearchType searchType = SearchType.DEPART_FROM;
 
     public void setFareCalculatorJson(String fareCalculatorJson) {
         // first, check to see if this is a built-in R5 fare calculator JSON representation
@@ -80,6 +82,7 @@ public void reset() {
 
         maxFare = DEFAULT_MAX_FARE;
         fareCalculator = null;
+        searchType = SearchType.DEPART_FROM;
         // do not reset transitLayer
     }
 }

r-package/DESCRIPTION

@@ -1,7 +1,7 @@
 Type: Package
 Package: r5r
 Title: Rapid Realistic Routing with 'R5'
-Version: 2.2.0
+Version: 2.2.099999
 Authors@R: c(
     person("Marcus", "Saraiva", , "[email protected]", role = "aut",
            comment = c(ORCID = "0000-0001-6218-2338")),

r-package/NAMESPACE

@@ -1,6 +1,7 @@
 # Generated by roxygen2: do not edit by hand
 
 export(accessibility)
+export(arrival_travel_time_matrix)
 export(detailed_itineraries)
 export(download_r5)
 export(expanded_travel_time_matrix)

r-package/NEWS.md

@@ -1,7 +1,8 @@
-# r5r 2.3.0
+# r5r 2.3.0 dev
 
 **Major changes**
 
+- New function `arrival_travel_time_matrix()` to calculate travel time matrix between origin destination pairs considering the time of arrival, instead of a depature time.
 
 **Minor changes**