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,16 @@
+package org.opentripplanner.routing.impl;
+
+import org.opentripplanner.street.search.state.State;
+
+public class BatteryValidator {
+
+  public static boolean wouldBatteryRunOut(Object current) {
+    State state = (State) current;
+    double traversedBatteryMeters = state.traversedBatteryMeters;
+    double currentRangeMeters = state.currentRangeMeters;
+    if (currentRangeMeters == Double.POSITIVE_INFINITY) {
+      return false;
+    }
+    return currentRangeMeters < traversedBatteryMeters;
+  }
+}

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

@@ -7,7 +7,10 @@
 import java.util.Set;
 import javax.annotation.Nullable;
 import org.opentripplanner.astar.model.GraphPath;
+import org.opentripplanner.astar.spi.SkipEdgeStrategy;
 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,9 +91,7 @@ public List<GraphPath<State, Edge, Vertex>> getPaths(
       .of()
       .setHeuristic(new EuclideanRemainingWeightHeuristic(maxCarSpeed))
       .setSkipEdgeStrategy(
-        new DurationSkipEdgeStrategy(
-          preferences.maxDirectDuration().valueOf(request.journey().direct().mode())
-        )
+        getSkipEdgeStrategy(request, preferences)
       )
       // FORCING the dominance function to weight only
       .setDominanceFunction(new DominanceFunctions.MinimumWeight())
@@ -119,6 +120,24 @@ public List<GraphPath<State, Edge, Vertex>> getPaths(
     return paths;
   }
 
+  /**
+   * chooses which SkipEdge Strategies to use, based on if the Mode includes rental
+   * @return a ComposingSkipEdgeStrategy if mode includes rental, else selects the DurationSkipStrategy
+   */
+  private static SkipEdgeStrategy getSkipEdgeStrategy(RouteRequest request, StreetPreferences preferences) {
+    if(request.journey().direct().mode().includesRenting()){
+      return new ComposingSkipEdgeStrategy<>(
+        new DurationSkipEdgeStrategy(
+          preferences.maxDirectDuration().valueOf(request.journey().direct().mode())
+        ),
+        new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut)
+      );
+    }
+    return new DurationSkipEdgeStrategy(
+      preferences.maxDirectDuration().valueOf(request.journey().direct().mode())
+    );
+  }
+
   /**
    * Try to find N paths through the Graph
    */

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

@@ -101,4 +101,6 @@ default boolean networkIsNotAllowed(VehicleRentalPreferences preferences) {
 
     return !preferences.allowedNetworks().contains(getNetwork());
   }
+
+  double getCurrentRangeMeters();
 }

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

@@ -177,6 +177,11 @@ public VehicleRentalSystem getVehicleRentalSystem() {
     return system;
   }
 
+  @Override
+  public double getCurrentRangeMeters() {
+    return Double.POSITIVE_INFINITY;
+  }
+
   @Override
   public String toString() {
     return String.format(

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,12 @@ public VehicleRentalStationUris getRentalUris() {
   public VehicleRentalSystem getVehicleRentalSystem() {
     return system;
   }
+
+  @Override
+  public double getCurrentRangeMeters() {
+    if (currentRangeMeters == null) {
+      return Double.POSITIVE_INFINITY;
+    }
+    return 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,8 @@ private static Set<RentalFormFactor> allowedModes(StreetMode streetMode) {
       default -> Set.of();
     };
   }
+
+  public double getCurrentRangeMeters() {
+    return vertex.getStation().getCurrentRangeMeters();
+  }
 }

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 (s1.isRentingVehicle()) {
+      s1.incrementTraversedBatteryMeters(getDistanceWithElevation());
+    }
+
     if (costExtension != null) {
       weight += costExtension.calculateExtraCost(s0, length_mm, traverseMode);
     }

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

@@ -52,6 +52,13 @@ 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 traversedBatteryMeters;
+
+  //the available battery distance of a currently selected sharing vehicle
+  //setting a magic value of 0.0 to make sure
+  public double currentRangeMeters;
+
   /* CONSTRUCTORS */
 
   /**
@@ -82,6 +89,8 @@ public State(
         vertex.rentalRestrictions().noDropOffNetworks();
     }
     this.walkDistance = 0;
+    this.traversedBatteryMeters = 0;
+    this.currentRangeMeters = Double.POSITIVE_INFINITY;
     this.time = startTime.getEpochSecond();
   }
 
@@ -360,6 +369,8 @@ public State reverse() {
       editor.incrementTimeInSeconds(orig.getAbsTimeDeltaSeconds());
       editor.incrementWeight(orig.getWeightDelta());
       editor.incrementWalkDistance(orig.getWalkDistanceDelta());
+      editor.incrementTraversedBatteryMeters(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.traversedBatteryMeters - backState.traversedBatteryMeters);
+    } else {
+      return 0.0;
+    }
+  }
+
+  private double getCurrentRangeMeters() {
+    if (backState != null) {
+      return backState.currentRangeMeters;
+    } else {
+      return Double.POSITIVE_INFINITY;
+    }
+  }
+
   private State reversedClone() {
     StreetSearchRequest reversedRequest = request
       .copyOfReversed(getTime())

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

@@ -196,6 +196,19 @@ public void incrementWalkDistance(double length) {
     child.walkDistance += length;
   }
 
+  public void incrementTraversedBatteryMeters(double length) {
+    if (length < 0) {
+      LOG.warn("A state's battery distance is being incremented by a negative amount.");
+      defectiveTraversal = true;
+      return;
+    }
+    child.traversedBatteryMeters += length;
+  }
+
+  public void setCurrentRangeMeters(double currentRangeMeters) {
+    child.currentRangeMeters = currentRangeMeters;
+  }
+
   /* Basic Setters */
 
   public void resetEnteredNoThroughTrafficArea() {
@@ -389,4 +402,8 @@ private void cloneStateDataAsNeeded() {
     if (child.backState != null && child.stateData == child.backState.stateData) child.stateData =
       child.stateData.clone();
   }
+
+  public boolean isRentingVehicle() {
+    return child.isRentingVehicle();
+  }
 }

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

@@ -0,0 +1,87 @@
+package org.opentripplanner.astar.strategy;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+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 = 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 = 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 = 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 = 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 = Double.POSITIVE_INFINITY;
+
+    var strategy = new BatteryDistanceSkipEdgeStrategy(BatteryValidator::wouldBatteryRunOut);
+    assertFalse(strategy.shouldSkipEdge(state, null));
+  }
+
+  private static State getState(double traversedBatteryMeters) {
+    var state = TestStateBuilder.ofScooterRental().build();
+    state.traversedBatteryMeters = traversedBatteryMeters;
+    return state;
+  }
+}