Take rental vehicle battery level into account

src/main/java/org/opentripplanner/astar/strategy/BatteryDistanceSkipEdgeStrategy.java

@@ -0,0 +1,27 @@
+package org.opentripplanner.astar.strategy;
+
+import java.util.function.Predicate;
+import org.opentripplanner.astar.spi.AStarEdge;
+import org.opentripplanner.astar.spi.AStarState;
+import org.opentripplanner.astar.spi.SkipEdgeStrategy;
+
+/**
+ * Skips Edges when the available battery distance of a vehicle is less than the accumulated driving
+ * distance of the same vehicle
+ */
+public class BatteryDistanceSkipEdgeStrategy<
+  State extends AStarState<State, Edge, ?>, Edge extends AStarEdge<State, Edge, ?>
+>
+  implements SkipEdgeStrategy<State, Edge> {
+
+  private final Predicate<State> shouldSkip;
+
+  public BatteryDistanceSkipEdgeStrategy(Predicate<State> shouldSkip) {
+    this.shouldSkip = shouldSkip;
+  }
+
+  @Override
+  public boolean shouldSkipEdge(State current, Edge edge) {
+    return shouldSkip.test(current);
+  }
+}

src/main/java/org/opentripplanner/routing/impl/BatteryValidator.java

@@ -0,0 +1,17 @@
+package org.opentripplanner.routing.impl;
+
+import java.util.Optional;
+import org.opentripplanner.street.search.state.State;
+
+public class BatteryValidator {
+
+  public static boolean wouldBatteryRunOut(Object current) {
+    double drivenBatteryMeters =
+      ((org.opentripplanner.street.search.state.State) current).drivenBatteryMeters;
+    Optional<Double> currentRangeMeters = ((State) current).currentRangeMeters;
+    if (currentRangeMeters.isEmpty()) {
+      return false;
+    }
+    return currentRangeMeters.get() < drivenBatteryMeters;
+  }
+}

src/main/java/org/opentripplanner/routing/impl/GraphPathFinder.java

@@ -8,6 +8,8 @@
 import javax.annotation.Nullable;
 import org.opentripplanner.astar.model.GraphPath;
 import org.opentripplanner.astar.spi.TraverseVisitor;
+import org.opentripplanner.astar.strategy.BatteryDistanceSkipEdgeStrategy;
+import org.opentripplanner.astar.strategy.ComposingSkipEdgeStrategy;
 import org.opentripplanner.astar.strategy.DurationSkipEdgeStrategy;
 import org.opentripplanner.astar.strategy.PathComparator;
 import org.opentripplanner.ext.dataoverlay.routing.DataOverlayContext;
@@ -88,8 +90,11 @@ public List<GraphPath<State, Edge, Vertex>> getPaths(
       .of()
       .setHeuristic(new EuclideanRemainingWeightHeuristic(maxCarSpeed))
       .setSkipEdgeStrategy(
-        new DurationSkipEdgeStrategy(
-          preferences.maxDirectDuration().valueOf(request.journey().direct().mode())
+        new ComposingSkipEdgeStrategy<>(
+          new DurationSkipEdgeStrategy(
+            preferences.maxDirectDuration().valueOf(request.journey().direct().mode())
+          ),
+          new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut)
         )
       )
       // FORCING the dominance function to weight only

src/main/java/org/opentripplanner/service/vehiclerental/model/VehicleRentalVehicle.java

@@ -1,6 +1,7 @@
 package org.opentripplanner.service.vehiclerental.model;
 
 import java.time.Instant;
+import java.util.Optional;
 import java.util.Set;
 import org.opentripplanner.framework.i18n.I18NString;
 import org.opentripplanner.street.model.RentalFormFactor;
@@ -133,4 +134,8 @@ public VehicleRentalStationUris getRentalUris() {
   public VehicleRentalSystem getVehicleRentalSystem() {
     return system;
   }
+
+  public Optional<Double> getCurrentRangeMeters() {
+    return Optional.ofNullable(currentRangeMeters);
+  }
 }

src/main/java/org/opentripplanner/service/vehiclerental/street/VehicleRentalEdge.java

@@ -1,11 +1,13 @@
 package org.opentripplanner.service.vehiclerental.street;
 
 import java.util.Collections;
+import java.util.Optional;
 import java.util.Set;
 import javax.annotation.Nonnull;
 import org.opentripplanner.framework.i18n.I18NString;
 import org.opentripplanner.routing.api.request.StreetMode;
 import org.opentripplanner.service.vehiclerental.model.VehicleRentalPlace;
+import org.opentripplanner.service.vehiclerental.model.VehicleRentalVehicle;
 import org.opentripplanner.street.model.RentalFormFactor;
 import org.opentripplanner.street.model.edge.Edge;
 import org.opentripplanner.street.search.state.State;
@@ -19,10 +21,12 @@
 public class VehicleRentalEdge extends Edge {
 
   public final RentalFormFactor formFactor;
+  private final VehicleRentalPlaceVertex vertex;
 
   private VehicleRentalEdge(VehicleRentalPlaceVertex vertex, RentalFormFactor formFactor) {
     super(vertex, vertex);
     this.formFactor = formFactor;
+    this.vertex = vertex;
   }
 
   public static VehicleRentalEdge createVehicleRentalEdge(
@@ -169,6 +173,7 @@ public State[] traverse(State s0) {
         ? (int) preferences.pickupTime().toSeconds()
         : (int) preferences.dropOffTime().toSeconds()
     );
+    s1.setCurrentRangeMeters(getCurrentRangeMeters());
     s1.setBackMode(null);
     return s1.makeStateArray();
   }
@@ -206,4 +211,11 @@ private static Set<RentalFormFactor> allowedModes(StreetMode streetMode) {
       default -> Set.of();
     };
   }
+
+  public Optional<Double> getCurrentRangeMeters() {
+    if (vertex.getStation() instanceof VehicleRentalVehicle) {
+      return ((VehicleRentalVehicle) vertex.getStation()).getCurrentRangeMeters();
+    }
+    return Optional.empty();
+  }
 }

src/main/java/org/opentripplanner/street/model/edge/StreetEdge.java

@@ -1183,6 +1183,10 @@ private StateEditor doTraverse(State s0, TraverseMode traverseMode, boolean walk
       s1.incrementWalkDistance(getDistanceWithElevation());
     }
 
+    if (traverseMode.isCyclingIsh() && s1.isVehicleRentable()) {
+      s1.incrementDrivenBatteryMeters(getDistanceWithElevation());
+    }
+
     if (costExtension != null) {
       weight += costExtension.calculateExtraCost(s0, length_mm, traverseMode);
     }

src/main/java/org/opentripplanner/street/search/state/State.java

@@ -6,6 +6,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
 import javax.annotation.Nonnull;
@@ -52,6 +53,12 @@ public class State implements AStarState<State, Edge, Vertex>, Cloneable {
   // we should DEFINITELY rename this variable and the associated methods.
   public double walkDistance;
 
+  // how far a sharing vehicle powered by battery has driven
+  public double drivenBatteryMeters;
+
+  //the available battery distance of a currently selected sharing vehicle
+  public Optional<Double> currentRangeMeters;
+
   /* CONSTRUCTORS */
 
   /**
@@ -82,6 +89,8 @@ public State(
         vertex.rentalRestrictions().noDropOffNetworks();
     }
     this.walkDistance = 0;
+    this.drivenBatteryMeters = 0;
+    this.currentRangeMeters = Optional.empty();
     this.time = startTime.getEpochSecond();
   }
 
@@ -360,6 +369,8 @@ public State reverse() {
       editor.incrementTimeInSeconds(orig.getAbsTimeDeltaSeconds());
       editor.incrementWeight(orig.getWeightDelta());
       editor.incrementWalkDistance(orig.getWalkDistanceDelta());
+      editor.incrementDrivenBatteryMeters(orig.getBatteryDistanceDelta());
+      editor.setCurrentRangeMeters(orig.getCurrentRangeMeters());
 
       // propagate the modes through to the reversed edge
       editor.setBackMode(orig.getBackMode());
@@ -503,6 +514,22 @@ private double getWalkDistanceDelta() {
     }
   }
 
+  private double getBatteryDistanceDelta() {
+    if (backState != null) {
+      return Math.abs(this.drivenBatteryMeters - backState.drivenBatteryMeters);
+    } else {
+      return 0.0;
+    }
+  }
+
+  private Optional<Double> getCurrentRangeMeters() {
+    if (backState != null) {
+      return backState.currentRangeMeters;
+    } else {
+      return Optional.empty();
+    }
+  }
+
   private State reversedClone() {
     StreetSearchRequest reversedRequest = request
       .copyOfReversed(getTime())

src/main/java/org/opentripplanner/street/search/state/StateEditor.java

@@ -1,5 +1,6 @@
 package org.opentripplanner.street.search.state;
 
+import java.util.Optional;
 import java.util.Set;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -196,6 +197,19 @@ public void incrementWalkDistance(double length) {
     child.walkDistance += length;
   }
 
+  public void incrementDrivenBatteryMeters(double length) {
+    if (length < 0) {
+      LOG.warn("A state's battery distance is being incremented by a negative amount.");
+      defectiveTraversal = true;
+      return;
+    }
+    child.drivenBatteryMeters += length;
+  }
+
+  public void setCurrentRangeMeters(Optional<Double> currentRangeMeters) {
+    child.currentRangeMeters = currentRangeMeters;
+  }
+
   /* Basic Setters */
 
   public void resetEnteredNoThroughTrafficArea() {
@@ -389,4 +403,8 @@ private void cloneStateDataAsNeeded() {
     if (child.backState != null && child.stateData == child.backState.stateData) child.stateData =
       child.stateData.clone();
   }
+
+  public boolean isVehicleRentable() {
+    return child.isRentingVehicle();
+  }
 }

src/test/java/org/opentripplanner/astar/strategy/BatteryDistanceSkipEdgeStrategyTest.java

@@ -0,0 +1,88 @@
+package org.opentripplanner.astar.strategy;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+import org.opentripplanner.routing.algorithm.GraphRoutingTest;
+import org.opentripplanner.routing.impl.BatteryValidator;
+import org.opentripplanner.street.search.state.State;
+import org.opentripplanner.street.search.state.TestStateBuilder;
+
+public class BatteryDistanceSkipEdgeStrategyTest extends GraphRoutingTest {
+
+  /**
+   * battery is not enough for driven distance-> skips Edge
+   * battery is 0m, driven meters = 100 => true
+   */
+  @Test
+  void batteryIsNotEnough() {
+    var state = getState(100.0);
+
+    state.currentRangeMeters = Optional.of(0.0);
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+
+    assertTrue(strategy.shouldSkipEdge(state, null));
+  }
+
+  /**
+   * battery is enough for driven distance-> does not skip Edge
+   * battery is 4000m, driven meters = 100 => false
+   */
+  @Test
+  void batteryIsEnough() {
+    var state = getState(100.0);
+    state.currentRangeMeters = Optional.of(4000.0);
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+    assertFalse(strategy.shouldSkipEdge(state, null));
+  }
+
+  /**
+   * battery dies at exact time location is reached -> does not skip edge
+   * battery is 100m, driven meters = 100 => false
+   */
+  @Test
+  void batteryDiesAtFinalLocation() {
+    var state = getState(100.0);
+
+    state.currentRangeMeters = Optional.of(100.0);
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+    assertFalse(strategy.shouldSkipEdge(state, null));
+  }
+
+  /**
+   * battery has remaining Energy, no distance was driven so far -> does not skip edge
+   * battery is 100m, driven meters = 0 => false
+   */
+  @Test
+  void noDrivenMeters() {
+    var state = getState(0.0);
+    state.currentRangeMeters = Optional.of(100.0);
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+    assertFalse(strategy.shouldSkipEdge(state, null));
+  }
+
+  /**
+   * vehicle.currentRangeMeters (battery) is Null or of Empty Value -> does not skip Edge
+   * Battery is Optional.Empty() => false
+   */
+  @Test
+  void batteryHasNoValue() {
+    var state = TestStateBuilder.ofScooterRental().build();
+    state.currentRangeMeters = Optional.empty();
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+    assertFalse(strategy.shouldSkipEdge(state, null));
+  }
+
+  private static State getState(double drivenBatteryMeters) {
+    var state = TestStateBuilder.ofScooterRental().build();
+    state.drivenBatteryMeters = drivenBatteryMeters;
+    return state;
+  }
+}

test/performance/norway/travelSearch-expected-results.csv

@@ -149,4 +149,5 @@ tcId,nTransfers,duration,cost,walkDistance,startTime,endTime,agencies,modes,rout
 239,0,00:42:00,7360,994,10:00:00,10:42:00,,,,,Walk 13m37s ~ YTI:Vehicle:de703d2ea4b03d6af6b8837fd90e5e5ef95f3b9490c194fc8617924314c5427d Rental  28m23s
 240,0,00:50:54,8937,994,10:00:00,10:50:54,,,,,Walk 13m37s ~ YTI:Vehicle:de703d2ea4b03d6af6b8837fd90e5e5ef95f3b9490c194fc8617924314c5427d Rental  37m17s
 241,0,00:46:40,7954,994,10:00:00,10:46:40,,,,,Walk 13m37s ~ YTI:Vehicle:de703d2ea4b03d6af6b8837fd90e5e5ef95f3b9490c194fc8617924314c5427d Rental  33m3s
-242,0,01:03:31,9788,994,10:00:00,11:03:31,,,,,Walk 13m37s ~ YTI:Vehicle:de703d2ea4b03d6af6b8837fd90e5e5ef95f3b9490c194fc8617924314c5427d Rental  49m54s
+242,0,01:03:31,9788,994,10:00:00,11:03:31,,,,,Walk 13m37s ~ YTI:Vehicle:de703d2ea4b03d6af6b8837fd90e5e5ef95f3b9490c194fc8617924314c5427d Rental  49m54s
+243,0,2:03:31,13000,13000,10:00:00,12:03:31,,,,,Walk 2h03m31s

test/performance/norway/travelSearch.csv

@@ -86,3 +86,4 @@ testCaseId,description,departure,arrival,window,origin,fromPlace,fromLat,fromLon
 240,Eiksmarka to Kvadraturen,10:00,,,Eiksmarka,,59.9463,10.6263,Kvadraturen,,59.9109,10.7423,scooter-rent,WALK|SCOOTER_RENT
 241,Eiksmarka to Bergskogen,10:00,,,Eiksmarka,,59.9463,10.6263,Bergskogen,,59.94770,10.74223,scooter-rent,WALK|SCOOTER_RENT
 242,Eiksmarka to Refstad,10:00,,,Eiksmarka,,59.9463,10.6263,Refstad,,59.9388,10.8012,scooter-rent,WALK|SCOOTER_RENT
+243,Oslo to Ekeberg,10:00,,,Oslo,,59.917696,10.735079,Ekeberg,,59.8896,10.79424,scooter-rent,WALK|SCOOTER_RENT