Modeling Battery-Range Constraints for EV Fleets

Fleet dispatch systems fail quietly when they treat electric-vehicle range as a flat distance cutoff instead of an accumulating energy budget. This page is the modeling layer underneath EV fleet charging-aware route optimization, the section of Routing API Automation & Fleet Integration that covers energy models, charger snapping, and stop insertion for delivery EVs — it focuses narrowly on producing a trustworthy per-edge energy cost and state-of-charge trace, which every other technique in that section depends on.

Where inserting charging stops in route optimization decides where to detour once a battery is running low, this page addresses what feeds that decision: converting road-network geometry, grade, and payload into kilowatt-hours per edge, accumulating that into a state-of-charge trace, and pruning the graph to the set of nodes actually reachable before a safety reserve is breached. Get the energy model wrong and every downstream charging decision — early, late, or entirely missed — inherits the error.

When to Use This Approach

A flat range cutoff (for example, “exclude stops beyond 120 km”) is adequate only for near-flat service areas with uniform payload and mild climate. Build an explicit energy-per-edge model instead when any of the following apply:

• The service area has meaningful elevation change — hilly last-mile zones or regional line-haul routes where climbs and descents are a large fraction of total distance.
• Payload varies materially between routes or across a single multi-stop route as parcels are delivered and the vehicle gets lighter.
• The fleet mixes vehicle classes (cargo van, box truck, cargo bike) with different mass, drag, and drivetrain efficiency, so a single range number per vehicle type is wrong for the rest.
• Dispatch needs a defensible answer to “how much reserve is left at stop 7,” not just “did the route fit under the range limit.”
• You are about to build charging-stop insertion and need a continuous state-of-charge signal to trigger detours against, rather than a binary in-range/out-of-range flag.

If none of these apply — a single vehicle type, flat terrain, fixed payload, short routes well inside rated range — a flat distance buffer is simpler and the energy model below is unnecessary engineering overhead.

Implementation

The model has two stages: a vectorized per-edge energy function, then a cumulative state-of-charge trace with reachability pruning. Both operate on NumPy arrays so they scale to graphs with hundreds of thousands of edges without a Python-level loop.

# requires: numpy>=1.24 (pip install numpy)
# Python 3.9+

import numpy as np

G_ACCEL = 9.81       # m/s^2
AIR_DENSITY = 1.225  # kg/m^3 at sea level, 15C


def edge_energy_kwh(
    distance_m: np.ndarray,
    grade_pct: np.ndarray,
    speed_kmh: np.ndarray,
    payload_kg: np.ndarray,
    vehicle_mass_kg: float,
    frontal_area_m2: float = 4.2,
    drag_coeff: float = 0.65,
    rolling_coeff: float = 0.0095,
    drivetrain_eff: float = 0.88,
    regen_eff: float = 0.55,
    aux_power_kw: float = 1.8,
) -> np.ndarray:
    """Vectorized per-edge traction + auxiliary energy cost, in kWh.

    All array arguments share one row per graph edge. Positive grade_pct
    is climbing; negative is descending, where recovered energy is capped
    by regen_eff and a hardware recovery limit below.
    """
    mass = vehicle_mass_kg + payload_kg              # kg, broadcasts per edge
    theta = np.arctan(grade_pct / 100.0)              # radians
    speed_ms = speed_kmh / 3.6

    f_grade = mass * G_ACCEL * np.sin(theta)          # N
    f_roll = mass * G_ACCEL * rolling_coeff * np.cos(theta)
    f_aero = 0.5 * AIR_DENSITY * drag_coeff * frontal_area_m2 * speed_ms ** 2
    f_total = f_grade + f_roll + f_aero               # N, signed

    work_j = f_total * distance_m                     # Joules, signed
    traction_kwh = np.where(
        work_j >= 0,
        work_j / drivetrain_eff,                       # motoring: efficiency loss
        work_j * regen_eff,                             # braking: efficiency gain (negative)
    ) / 3.6e6

    travel_time_h = (distance_m / 1000.0) / np.maximum(speed_kmh, 1e-6)
    aux_kwh = aux_power_kw * travel_time_h             # HVAC, telematics, refrigeration

    edge_kwh = traction_kwh + aux_kwh

    # Hardware-limited regen recovery cap — batteries and inverters throttle
    # charge acceptance; a descent cannot recover more than this fraction
    # of the potential energy released.
    regen_cap_kwh = -0.35 * (mass * G_ACCEL * distance_m) / 3.6e6
    return np.maximum(edge_kwh, regen_cap_kwh)

The second stage accumulates energy cost into a state-of-charge trace and derives the reachable subset of an ordered node sequence — typically the output of a single-source shortest-path pass where weight is edge_kwh rather than distance:

# requires: numpy>=1.24 (pip install numpy)
# Python 3.9+

def soc_trace(
    edge_kwh: np.ndarray,
    battery_capacity_kwh: float,
    start_soc_pct: float = 100.0,
) -> np.ndarray:
    """Cumulative state-of-charge (%) after each edge along an ordered route.

    Negative values are left unclipped on the low end so infeasible legs
    are visible to validation code rather than silently masked.
    """
    cum_kwh = np.cumsum(edge_kwh)
    soc_pct = start_soc_pct - (cum_kwh / battery_capacity_kwh) * 100.0
    return np.minimum(soc_pct, 100.0)


def reachable_mask(
    edge_kwh: np.ndarray,
    remaining_kwh: float,
    reserve_kwh: float,
) -> np.ndarray:
    """Boolean mask over an ordered edge sequence: True while cumulative
    energy stays within the usable budget above the safety reserve.

    Intended for use against nx.single_source_dijkstra_path_length(G,
    source, weight="energy_kwh") output, sorted by cumulative cost, so the
    mask marks the reachable frontier before energy is exhausted.
    """
    cum_kwh = np.cumsum(edge_kwh)
    budget_kwh = remaining_kwh - reserve_kwh
    return cum_kwh <= budget_kwh


# Example: six-stop delivery leg, moderate climb then a long descent
distances = np.array([1800, 2400, 1600, 3100, 2000, 2600])       # meters
grades = np.array([1.5, 3.2, 4.8, -2.0, -5.5, 0.4])               # percent
speeds = np.array([40, 35, 25, 45, 50, 40])                       # km/h
payload = np.array([620, 590, 540, 480, 430, 430])                # kg, decreasing as stops complete

costs = edge_energy_kwh(distances, grades, speeds, payload, vehicle_mass_kg=2400)
soc = soc_trace(costs, battery_capacity_kwh=62.0, start_soc_pct=88.0)
reachable = reachable_mask(costs, remaining_kwh=0.88 * 62.0, reserve_kwh=0.15 * 62.0)

print("edge_kwh:", np.round(costs, 3))
print("soc_pct :", np.round(soc, 1))
print("reachable:", reachable)

Both functions are pure NumPy — no Python-level iteration over edges — so applying edge_energy_kwh across an entire OSM-derived edge table with pandas is a single vectorized call rather than a DataFrame.apply() loop, which matters once the graph has more than a few thousand edges.

Key Parameters and Tuning

Grade sign convention. Positive grade_pct must mean climbing throughout the pipeline. If grade is derived from a DEM by subtracting elevation at edge endpoints, verify the sign matches the direction of travel used elsewhere in the graph — a graph traversed in both directions needs grade recomputed per direction, not a single signed value copied to the reverse edge.

Payload decay along a route. For multi-stop delivery runs, payload should decrease stop by stop as parcels are dropped, not stay fixed at the loaded weight for the whole route. Recompute payload_kg per edge from the manifest rather than using a single average, particularly on routes with a few heavy pallets delivered early.

Integration Points

The energy model produces a per-edge cost that plugs into the same graph structures used elsewhere on this site, alongside distance and time weights rather than replacing them:

NetworkX. Store edge_kwh as an edge attribute (G.edges[u, v]["energy_kwh"] = ...) parallel to the weights used in NetworkX shortest path algorithms for logistics. Running nx.single_source_dijkstra_path_length(G, source, weight="energy_kwh") gives cumulative energy cost to every node in one pass, which is the direct input to reachable_mask above — this is the energy-domain equivalent of isochrone construction, substituting kWh for travel time.

OSRM and Valhalla. Neither engine has a native battery-energy cost model, so the energy-constrained subgraph is computed in Python first, then only the reachable node set is passed downstream — either as a bounding filter on candidate waypoints or as a hard exclusion list before requesting turn-by-turn geometry. This mirrors how Valhalla configuration for multi-modal analysis layers custom costing on top of a general-purpose engine rather than inside it.

Charging-stop insertion. The soc_trace output is the trigger signal consumed by inserting charging stops in route optimization: whenever the trace crosses the reserve threshold, that stage searches for a feasible charger detour before the crossing point, rather than after the vehicle is already stranded.

Speed inputs. The speed_kmh array should come from calibrated speed profiles rather than posted limits, since real-world speed strongly affects both aerodynamic drag and travel time. See speed profile calibration for heavy vehicles and, for the EV-specific case, calibrating speed profiles for electric delivery fleets, which covers acceleration-heavy urban stop-and-go patterns that this energy model treats as a constant speed_kmh per edge — a simplification worth revisiting if urban energy estimates run consistently high.

Payload decay is worth modelling explicitly rather than averaging, because the error it introduces is not symmetric. Holding payload at the loaded weight for the whole run overstates consumption on every leg after the first heavy drop, which quietly inserts charging stops the vehicle never needed.

Validation Checklist

1. Flat-road sanity check. With grade_pct = 0 and payload at the manufacturer’s test configuration, edge_energy_kwh summed over 100 km should land within roughly 10% of the published WLTP or EPA consumption figure (kWh/100 km). Larger deviations point to a wrong drivetrain_eff or Cd value.

2. Regen cap enforcement. For any edge with grade_pct < 0, assert edge_kwh >= regen_cap_kwh and that no single descent produces a state-of-charge gain exceeding what the regen cap allows over that edge’s distance.

3. State-of-charge floor. reachable_mask must never mark a node reachable when its cumulative energy cost exceeds remaining_kwh - reserve_kwh. Test this directly with a synthetic route engineered to cross the reserve mid-route.

4. Telemetry cross-check. On a handful of completed real-world routes with logged SoC, compare soc_trace output against the actual telemetry curve. Mean absolute error under roughly 3 percentage points across a route is a reasonable production bar; larger errors usually trace back to grade resolution or an uncalibrated aux_power_kw.

5. Payload sensitivity. Holding grade and speed fixed, scaling payload_kg from 0 to the vehicle’s rated maximum should produce a monotonic, roughly linear increase in edge_kwh on flat terrain. A non-monotonic result indicates a sign error in the force terms.

6. Cross-vehicle regression. Running the same route through two vehicle profiles (for example, a cargo van and a cargo bike) should produce SoC deltas whose direction and rough magnitude match the difference in mass and drag coefficient — a useful smoke test before trusting the model across a mixed fleet.

Related

• EV fleet charging-aware route optimization — the parent guide covering energy models, charger snapping, and stop insertion together
• Inserting charging stops in route optimization — using the state-of-charge trace built here as the trigger for detour insertion
• Speed profile calibration for heavy vehicles — calibrated speed inputs that feed the aerodynamic and time-based terms of the energy model
• Calibrating speed profiles for electric delivery fleets — EV-specific acceleration and stop-and-go patterns that refine the constant-speed simplification used here