HAL Id: hal-01559524
https://hal.archives-ouvertes.fr/hal-01559524
Submitted on 10 Jul 2017
HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or
L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires
To cite this version:
Aurélien Froger, Jorge E. Mendoza, Ola Jabali, Gilbert Laporte. A Matheuristic for the Electric Vehicle Routing Problem with Capacitated Charging Stations. [Research Report] Centre interuni-versitaire de recherche sur les reseaux d’entreprise, la logistique et le transport (CIRRELT). 2017. �hal-01559524�
A Matheuristic for the Electric Vehicle
Routing Problem with Capacitated
Charging Stations
Aurélien Froger Jorge E. Mendoza Ola Jabali Gilbert Laporte June 2017 CIRRELT-2017-31Interuniversity Research Centre on Enterprise Networks, Logistics and Transportation (CIRRELT) and Department of Management Sciences, HEC Montréal, 3000 Côte-Sainte-Catherine, Montréal, Canada H3T 2A7
2 Université François-Rabelais de Tours, LI EA 6300, ROOT ERL CNRS 6305, Tours, France
3 Dipartimento di Elettronica, Informazione e Bioingegneria, Politecnico di Milano, Piazza Leonardo da Vinci, 32, Milano 20133, Italy
Abstract. Existing research on Electric vehicle routing problems (E-VRPs) assumes that charging stations (CSs) can simultaneously charge an unlimited number of electric vehicles. In practice, however, CSs have a limited number of chargers. In this research, we investigate the impact of considering these capacity restrictions. We focus on the electric vehicle routing problem with nonlinear charging function (E-VRP-NL). We first extend existing mixed integer linear programming formulations of the E-VRP-NL to deal with capacitated CSs. We then present a route-first assemble-second matheuristic to tackle the problem. In the first stage of this method, we rely on an existing metaheuristic to generate a pool of high-quality routes while relaxing the capacity constraints. In the second stage, we use a Benders' like decomposition to assemble a solution to the problem by assembling routes from the pool. We evaluate four different assembling strategies. The results suggest that our algorithm performs well on a set of instances adapted from the literature.
Keywords: Electric vehicle routing problem with nonlinear charging function, mixed integer linear programming, benders decomposition, matheuristic.
Acknowledgements. This research was partly funded in France by Agence Nationale de la Recherche through project e-VRO (ANR-15-CE22-0005-01).
Results and views expressed in this publication are the sole responsibility of the authors and do not necessarily reflect those of CIRRELT.
Les résultats et opinions contenus dans cette publication ne reflètent pas nécessairement la position du CIRRELT et n'engagent pas sa responsabilité.
_____________________________
* Corresponding author: [email protected]
Dépôt légal – Bibliothèque et Archives nationales du Québec Bibliothèque et Archives Canada, 2017
1. Introduction and motivation
Electric vehicle routing problems (E-VRPs) started to be studied by the Operational Research (OR) community only recently. They consist in designing routes to serve a set of customers using a fleet of electric vehicles (EVs). Due to their relatively short driving range the EVs can detour to charging stations (CSs) to replenish their battery. Decisions in E-VRPs concern not only the sequence in which the customers are to be served, but also where and how much to charge the batteries. It is safe to say that one of the key elements in E-VRPs is the modeling of the charging process. For instance, some studies assume that the vehicle is fully replenished whenever they detour to a CS. In the green vehicle routing problem (G-VRP) tackled by Erdo˘gan and Miller-Hooks (2012), Ko˘c and Karaoglan (2016), Montoya et al. (2016), andBartolini and Andelmin (2017), charging an EV is done in constant time, while in (Schneider et al., 2014), (Hiermann et al., 2016), (Keskin and ˘Catay, 2016), and (Desaulniers et al., 2016) the charging time linearly depends on the state of charge (SoC) of the EV at its arrival at the CS. The full charging policy may be too restrictive. To overcome its drawbacks and to potentially save energy and time, one possibility is to allow partial recharge. This policy has been investigated in (Bruglieri et al., 2015), (Desaulniers et al., 2016), (Felipe et al., 2014), (Montoya et al., 2017), and (Froger et al., 2017). The latter three have studied the case in which, like in practice, CSs may have different technologies. Additionally, to account for the nonlinear relation between the time spent charging and the amount of energy charged, Montoya et al. (2017) and Froger et al. (2017) modeled charging functions using piecewise linear expressions. This results in the definition of the electric vehicle routing problem with nonlinear charging function (E-VRP-NL).
It is noteworthy that the above-mentioned assume that the charging infrastructure is private, that is, that the CSs are always available. This is a plausible assumption, since large companies can decide to invest in their own Infrastructure to avoid dealing with the uncertainty in CSs availability (e.g, queues). However, to the best of our knowledge, one of the key assumptions in the E-VRPs defined in the literature is that the CSs are unca-pacitated, that is, they are able to simultaneously handle an unlimited number of EVs. In practice, however, each CS has a limited number of chargers which limits the number of EVs charging at the same time. Needless to say, neglecting the CS capacity constraints may lead to poor decisions in practice. For instance we ran a feasibility test on the 120 BKS for the E-VRP-NL reported in (Montoya et al., 2017) limiting the number of chargers per CS to 1, 2, 3, and 4. According to our results, nearly 50% of the Montoya et al. (2017) solutions become infeasible when only 1 charger is available. This figure drops to 11% and 2% for the cases with 2 and 3 chargers. On the other hand, when 4 chargers are available, all solutions remain feasible. It is worth noting that if a company decides to invest in out-of-the-depot charging infrastructure, there are few chances that they decide to install more than a couple of chargers at each CS. AppendixA presents the details of our feasibility test.
In this research we focus on the E-VRP-NL and we extend it to consider capacitated CSs. We call the resulting problem the E-VRP-NL with capacitated CSs (E-VRP-NL-C). We first propose several modeling alternatives for the E-VRP-NL-C built on top of existing
MILP formulations of the E-VRP-NL. Then, we present a two-stage matheuristic to tackle the problem. The first stage of the algorithm consists in building a pool of routes while not taking the capacity constraints into account. The second stage of the algorithm assembles the routes from the pool to build a solution to the E-VRP-NL-C. We propose different strategies based on a Benders’ like decomposition of the assembling problem. More specifically, the overall scheme of the approach consists in solving a set partitioning model and discarding, by means of cuts, all along the branch-and-bound tree, selections of routes that are infeasible or for which the total time is underestimated.
The remainder of this document is organized as follows. Section 2 formally introduces the E-VRP-NL-C. Section 3 describes MILP formulations of the problem. Section 4 presents a two-stage matheuristic approach to tackle the E-VRP-NL-C. Section 5 shows the compu-tational results of our carried out experiments. Finally, Section 6 concludes and outlines research perspectives.
2. Problem description
We define the electric vehicle routing problem with nonlinear charging function and capacitated stations (E-VRP-NL-C) as follows.
Let I be the set of customers that need to be served and F the set of charging stations (CSs) at which the vehicles can stop to recharge their battery. Each customer i P I has a service time gi. The customers are served using an unlimited and homogeneous fleet of
EVs. The vehicle driving-range is limited by a route duration limit Tmax. All the EVs have
a battery of capacity Q (expressed in kWh). At the beginning of the planning horizon, the EVs are located in a single depot that they leave fully charged. Traveling from one location i (the depot, a customer, or a CS) to another location j incurs a driving time tij ¥ 0 and
an energy consumption eij ¥ 0. Driving times and energy consumption both satisfy the
triangular inequality. Due to their limited battery capacity, EVs may require to stop en route at CSs. Charging operations can occur at any CS and EVs can be partially recharged. Each CS i P F has a capacity, given by the number Ci of available chargers. Each CS has
also a piecewise linear charging function Φip∆q that maps for an empty battery the time ∆
spent charging at i to the SoC of the vehicle when it leaves i. If q is the SoC of the EV when it arrives at i and ∆ the charging time, the SoC of the EV when it departs from i is given by Φip∆ Φ1i pqqq. We denote as Bi t0, . . . , biu the set of breakpoints of the charging function
at i (sorted in ascending order). We also introduce cik and aik to represent the charging time
and the SoC for breakpoint k P Bi of the CS i. For notational convenience, let ρik denote
the slope of the segment between ci,k1 and cik (i.e. ρik paik ai,k1q{pcik ci,k1q) and
ηik the y-intercept of the segment between ci,k1 and cik (i.e. ηik aik cikρik).
Feasible solutions to the E-VRP-NL-C satisfy the following conditions: 1. each customer is visited exactly once by a single vehicl;
2. each route starts and ends at the depot
3. each route satisfies the maximum-duration limit Tmax
4. each route is energy-feasible (i.e., the SoC of an EV when it arrives at and departs from any location is between 0 and Q)
5. no more than Ci EVs simultaneously charge at each CS i P F
The objective of the E-VRP-NL-C is to minimize the total time. The latter takes into account driving, service, and charging times. Due to the limited availability of CSs, it also includes the waiting times that may occur at CSs whenever an EV queues for a charger. 3. Mixed-integer linear programming formulations
In this section we extend the formulations propose in (Froger et al., 2017) for the closely-related E-VRP-NL to deal with CS capacity constraints. Their formulations belong to two different families: CS replication-based formulations and recharging path-based formula-tions. The former share the spirit of the MILP formulations that are most typically used in the E-VRP literature. The latter, on the other hand, correspond to an alternative model-ing strategy. Accordmodel-ing to their results rechargmodel-ing path-based formulations outperform CS replication-based formulations. We, however, decided to explore both types of formulations for the E-VRP-NL-C.
3.1. CS replication-based formulation
Similarly to the E-VRP-NL, the E-VRP-NL-C can be defined on a digraph G pV, Aq, where V t0u Y I Y F1 is the set of nodes and A is the set of arcs connecting nodes of V . The symbol 0 represents the depot. The set F1 contains βi copies of each CS i P F (i.e.,
|F1| ° iPF
βi). The value of βi corresponds to an upper bound on the number of visits to
CS i. Note that βi must be strictly greater than Ci; otherwise, the capacity constraints are
redundant. In the remainder of this manuscript, depending on the context, we refer to an element of F1 or Fi1 as a CS copy or as a charging operation. We denote as Fi1 F1 the set containing the βi copies of CS i (i.e., |Fi1| βi and F1
iPFFi1). We assume that Fi1 is
an ordered set and that its elements are numbered from 1 to βi. We use the preprocessing
technique presented in (Froger et al., 2017) to reduce the number of arcs in A. In a nutshell, this technique primarily removes arcs that can never been traveled as regards to the battery capacity.
3.1.1. The baseline model
According to the experiments carried out in (Froger et al., 2017), the best formulations of the E-VRP-NL use arc-based tracking variables for the SoC and the time. Binary variable xij is 1 if and only if an EV travels arc pi, jq P A. Continuous variables τij and yij track
(respectively) the time and SoC of an EV when it departs from vertex i P V to travel arc pi, jq. If no vehicle travels between nodes i and j, both variables are 0. Continuous variables qi and oi specify (according to the piecewise linear approximation of the charging function)
the SoC of an EV when it arrives at and departs from CS copy iP F1. Continuous variable ∆i represents the duration of the charging operation performed at CS copy iP F1. Let iP F1
be a CS copy and k P Bizt0u. We introduce the continuous variable φik representing the
amount of energy charged at i on the segment that lies between the points pci,k1, ai,k1q
and pcik, aikq. We also introduce the binary variable ωik taking the value of 1 if and only if
an EV charges at i on the segment between the points pci,k1, ai,k1q and pcik, aikq. In the
E-VRP-NL, optimal solutions are left-shifted schedules. Indeed, when minimizing the total time, there is no advantage to wait before serving any customer or before charging at any CS. In the E-VRP-NL-C, this does not hold since there are coupling constraints between the routes. As a matter of fact, it may sometimes be profitable to wait at a CS for an available charger rather than to go to another CS. Without loss of generality, we restrict waiting times to occur only before charging operations. We introduce a continuous variable ∇i representing the waiting time of an EV before the start of the charging operation iP F1.
By adapting the existing CS replication-based formulations of the E-VRP-NL, a baseline model of the E-VRP-NL-C denoted asrFCSs, is written as follows:
rFCSs min ¸ i,jPV tijxij ¸ iPF1 p∆i K∇iq ¸ iPI gi (1) subject to ¸ pi,jqPA xij 1, @i P I (2) ¸ pi,jqPA xij ¤ 1, @i P F1 (3) ¸ pj,iqPA xji ¸ pi,jqPA xij 0, @i P V (4) ¸ pi,jqPA pyij eijxijq ¸ pj,lqPA yjl, @j P I (5) ¸ pi,jqPA pyij eijxijq qj, @j P F1 (6) ¸ pj,lqPA yjl oj, @j P F1 (7) yij ¤ Q min lPF Yt0u eli xij, @pi, jq P A (8) yij ¥ eij min lPF Y0ejl xij, @pi, jq P A (9) qi φik¤ aikωik Qp1 ωikq, @i P F1,@k P Bizt0u (10) φik¤ paik ai,k1qωik, @i P F1,@k P Bizt0u (11) ¸ kPBizt0u ωik¥ ¸ pi,jqPA xij, @i P F1 (12) ωik¤ ¸ pi,jqPA xij, @i P F1,@k P Bizt0u (13) oi qi ¸ kPBizt0u φik, @i P F1 (14) ∆i ¸ kPBizt0u φik{ρik, @i P F1 (15) ¸ pi,jqPA,i0 pτij ptij pjq xijq ¸ pj,lqPA τjl, @j P I (16) ¸ pi,jqPA:i0 pτij tijxijq ∆j ∇j ¸ pj,lqPA τjl, @j P F1 (17) CIRRELT-2017-31
τij¤ pTmax tij pj tj0q xij, @pi, jq P A : i 0, j P I (18) τij¤ Tmax tij ∆minj tj0 xij, @pi, jq P A : i 0, j P F1 (19) ¸ ph,jqPA xhj ¤ ¸ ph,lqPA xhl, @i P F, @j, l P Fi1, j l (20) ¸ pj,hqPA:j0 τjh ∆j¥ ¸ pl,hqPA:l0 τlh ∆l, @i P F, @j, h P Fi1: j l (21) xijP t0, 1u, @pi, jq P A (22) τij¥ 0, @pi, jq P A : i 0 (23) yij ¥ 0, @pi, jq P A (24) qi¥ 0, oi¥ 0, ∆i ¥ 0, @i P F1 (25) φik¥ 0 @i P F1,@k P Bizt0u (26) ωikP t0, 1u @i P F1,@k P Bizt0u (27)
Equation (1) gives the objective of the problem. It includes the driving, service, and charging times, but also a weighted sum (with a parameter K ¡ 0) of the waiting times. Constraints (2) ensure that each customer is visited once. Constraints 3 ensure that each CS copy is visited at most once. Constraints (4) impose the flow conservation. Constraints (5) track the battery level at each customer. Constraints (6) track the battery level of the EV when it arrives at a CS copy. Constraints (7) track the battery level of the EV when it leaves a CS copy. Constraints (8) couple the yij and xij variables. Constraints (9) state
that if an EV traverses the arc pi, jq its SoC when leaving i must be enough to traverse the arc and then to reach the closest CS or the depot. Constraints (10) restrict the segments on which EVs can charge according to the state of charge they have at their arrival at CS copies. Constraints (11) restrict the charging amount that can be charged on each segment. Constraints (12) impose the activation of one segment whenever an EV visits a CS copy. Constraints (13) are valid inequalities. Constraints (14) define the state of charge after a charging operation. Constraints (15) define the time spent charging at each CS copy. Constraints (16) track the departure time at each customer. Constraints (17) track the departure time at CS copies. Constraints (18) and (19) couple the τij and xij variables.
Specifically, if an EV traverses an arcpi, jq, then its departure time must guarantee that the EV returns to the depot without exceeding the tour duration limit. Constraints (20) and (21) break symmetries created by the introduction of CS copies. These constraints ensure that the copies of CS i are visited in the reverse order they appear in Fi (i.e, a charging
operation j P Fi1 must start after a charging operation lP Fi1 if l ¡ j). The reverse order is used since departure time and charging duration variables take the value 0 when a CS copy is not visited. Finally, constraints (22)–(27) define the domain of the decision variables.
The E-VRP-NL-C is a combined routing (the EVs visiting customers) + scheduling (the charging operations) problem. To extend previous formulations of the E-VRP-NL to include the CS capacity constraints, we borrowed some ideas from the Resource Constrained Scheduling Problem (RCPSP) literature. More precisely, we propose two formulations, a flow-based and an event-based, drawing some inspiration from the models introduced by
Artigues et al. (2003) and Kon´e et al. (2011) for the RCPSP. There is, however, a major difference between our CS scheduling problem and the RCPSP or the related parallel machine scheduling problem: in our problem i) the duration of each task (i.e., charging operation) and ii) the number of tasks executed by each resource (i.e., charging station) are decision variables (they are problem parameters in the RCPSP). To the best of our knowledge this case has never been addressed in the literature before.
3.1.2. Flow-based modeling of the capacity constraints
In our flow-based formulation (hereafter referred to as FB), we consider Ci parallel
ma-chines for each CS iP F . Each machine can execute at any given time at most one job. Let iP F be a CS and 0i and βi 1 be two dummy charging operations (acting as the source and
the sink of the flow). We denote as F1i the set Fi1Y t0i, βi 1u of charging operations (CS
copies are here considered as charging operations). Without loss of generality, we can en-force that in any feasible solution, after the completion of an operation j P F1i, the resource
unit (charger) allocated to j is directly transferred to a unique operation lP F1i.
The FB formulation requires the following decision variables. Sequential binary variable ujl is equal to 1 if and only if charging operation l starts after the completion of charging
operation j¡ l (symmetry breaking constraints (21) impose that charging operation j starts before charging operation l j). Let now j, l P F1i be two charging operations (potentially
dummy) such that j ¡ l. Continuous flow variable fjl denotes the quantity of resource that
is transferred from charging operation j to charging operation l. For notational convenience, we define rCj : 1 for all j P Fi1 and rC0i : rCβi 1 : Ci.
For the sake of clarity, we provide here one example to illustrate the structure of the flow network. We consider in this example a CS i with 2 chargers (i.e. Ci 2) and we create 4
copies of the CS (βi 4). Figure 1 shows an example of four charging operations occurring
at this CS (hereafter referred to as Example 1). Figure 2 illustrates the structure of the flow network on this example and describes a feasible flow.
Figure 1: Charging operations at CS iP F
A flow-based formulation of the capacity constraints is as follows:
¸ lPF1i,l¡j flj ¸ pl,jqPA xlj @i P F, @j P Fi1 (28) CIRRELT-2017-31
Figure 2: Structure of the flow network for CS i (left) and a feasible flow (right) ¸ lPF1i,l¡j flj ¸ lPF1i,l j fjl 0, @i P F, @j P Fi1 (29) Ci ¸ lPF1i,l¡0i fl,0i 0, @i P F (30) ¸ lPF1i,l βi 1 fβi 1,l Ci 0, @i P F (31) ujh¥ ujl ulh 1, @i P F, @j, l, h P Fi1: j¡ l ¡ h (32) ¸ pl,hqPA τlh ∆l ¸ pj,hqPA τjh¥ pTmax ti0q pujl 1q , @i P F, @j, l P Fi1, j¡ l (33) fjl¤ minp rCj, rClqujl, @i P F, @pj, lq P Fi1, j¡ l (34) ujlP t0, 1u, @i P F, @j, l P Fi1, j¡ l (35) fjl¥ 0 @i P F, @j, l P F1i, j¡ l (36)
Constraints (28) state that a resource has to be allocated to a charging operation in Fi1 if an EV reaches the corresponding CS. Constraints (29)-(31) ensure the flow conservation. Constraints (32) express the transitivity of the precedence relations. Constraints (33) are the disjunctive constraints coupling the start time of j and l to ujl. The constraint is active
when ujl 1 and, in that case, it enforces the precedence relation between the charging
operations j and l (i.e., l cannot start before the completion of j). Constraints (34) couple the flow variables to the sequence variables. Constraints (35) and (36) define the domain of the decision variables.
3.1.3. Event-based formulation of the capacity constraints
This event-based formulation (hereafter referred to as EB) is inspired by the on/off event-based formulation introduced by Kon´e et al. (2011). Consider the start of a charging operation as an event. The intuition behind the EB formulation is to count the number of events that overlap with the execution of other charging operations and set a constraint on that number.
Similarly to the FB formulation, on the EB formulation we can write the CS capacity constraints independently for each CS i. We define binary variable vjl that is 1 if and only
if the charging operation at j P Fi1 starts at the same time as charging operation l P Fi1 (j ¥ l) or is still being processed after the start of l. We use the variables pvjlqjPF1
i:j¥l to count the number of chargers required during each time interval defined by the starting time
of a charging operation j and j 1. Figure 3 illustrates the definition of these variables for Example 1.
Figure 3: Illustration of the definition of variablespvjlqjPFi1:j¤l for CS i
An event-based formulation of the capacity constraints is as follows:
vjj ¸ ph,jqPA xhj, @i P F, @j P Fi1 (37) ¸ pl,hqPA τlh ∆l¥ ¸ pj,hqPA τjh p1 vjl vj,l 1q pTmax ti0q @i P F, @j, l P Fi1: j¡ l (38) j¸1 h0 vjh¤ jp1 vj,l 1 vjlq @i P F, @j, l P Fi1: j¡ l (39) ¸ jPFi1:j¥l vjl¤ Ci @i P F, @l P Fi1 (40) vjlP t0, 1u, @i P F, @j, l P Fi1: j¥ l (41)
Constraints (37) forces each charging operation j P Fi1 to activate variable vjj. Constraints
(38) ensure that if charging operation j ends before charging operation l starts, then the starting time of l is larger than the completion time of j. Constraints (39) enforce contiguity for the value of the vjl variables. Since charging operations are non-preemptive, we can
safely forbid cases where for j P F1 there exists l P Fi1 such that vjl 1, vj,l1 0,
and vj,l2 1. Constraints (40) limit the number of charging operations that can be simultaneously performed. Constraints (41) define the domain of the newly introduced decision variables.
3.2. Recharging path-based formulation
One drawback of the previous formulations is the need to replicate the CSs. If we want to ensure that no optimal solutions are cut off, the number of copies to create has to be large. However this yields impracticable MILPs. See (Froger et al., 2017) for a detailed discussion on this issue. To overcome this difficulty, Froger et al. (2017) propose an alternative modeling of the E-VRP-NL-C based on the concept of recharging paths (hereafter sometimes referred to simply as paths) between each couple of nodes (either customers or the depot).
The concept of recharging paths leads to the definition of the E-VRP-NL-C on a directed multigraph rG prV , rAq, where rV t0u Y I and rA is the set of arcs associated with paths connecting nodes of rV . Without preprocessing, the number of paths explodes with the
number of CSs and the number of customers. However, a large number of these arcs cannot be part of an optimal solution. A dominance rule can be applied to discard unpromising recharging paths. To find all the non-dominated paths, we use the procedure described in AppendixB. Let i, j P rV be two nodes such that i j. We define Pij as the set of
(non-dominated) recharging paths connecting node i to node j by visiting none or some CSs. Let P be the set of all recharging paths connecting any couple of nodes in the graph. Specifically, we have P i,jP rV ,ijPij. We denote oppq and dppq as the origin and destination of a path
p P P . For each path p, we define an arc in rA from oppq to dppq. Let us denote np as the
number of CSs in path p and let Lp t0, 1..., np 1u N be the set of CS positions in the
path p. Let ipp, lq be the CS at position l P Lp in path p. Additionally, if an EV can travel
from i to j without visiting any CS, we create the corresponding path (denoted p0
ij) and add
it to Pij.
A recharging path-based formulation of the E-VRP-NL-C involves the following decisions variables. Binary variable xp is 1 if and only if an EV travels recharging path p P P .
Continuous variables τp and yp track the time and SoC of an EV when it departs from
node oppq to dppq using path p. Continuous variables qpl and opl specify (according to
the piecewise linear approximation of the charging function) the SoC of an EV when it arrives at and departs from ipp, lq (i.e. the CS at position l P Lp). Continuous variable ∆pl
represent the duration of the charging operation performed at ipp, lq. Continuous variable φplk represents the amount of energy charged on the segment that lies between the points
pcipp,lq,k1, aipp,lq,k1q and pcipp,lq,k, aipp,lq,kq at the CS ipp, lq. Binary variables ωplk equal to one
if and only if an EV charges at the CS at position l in path p on the segment between the points pcipp,lq,k1, aipp,lq,k1q and pcipp,lq,k, aipp,lq,kq. Let ep and tp be the energy consumption
and the driving time associated with path p P P . Continuous variable ∇pl represents the
waiting time at the CS at position l in path p before charging. We also introduce starting and completion time for the charging operations. Continuous variables spl and dpl represent
the starting and completion time of the charging operation performed at ipp, lq. A path-based formulation of the E-VRP-NL-C, denoted as rPpaths, is as follows:
rFpaths min¸ pPP tpx p ¸ lPLp p∆pl ∇plq ¸ iPI gi (42) subject to ¸ jP rV ,ij ¸ pPPij xp 1, @i P I (43) ¸ jP rV ,ij ¸ pPPji xp ¸ jP rV ,ij ¸ pPPij xp 0, @i P rV (44) ¸ lP rV ,lj ¸ pPPlj yp epxp ¸ lPLp popl qplq ¸ lP rV ,lj ¸ pPPjl yp, @j P I (45) yp eoppq,ipp,0qxp qp0, @p P P (46) op,l1 eipp,l1q,ipp,lqxp qpl, @p P P, @l P Lpzt0u (47) 9
¸ iP rV ,i0 ¸ pPPi0 yp epxp ¸ lPLp popl qplq ¥ 0, @i P I (48) yp ¤ Qxp, @p P P (49) qpl φplk¤ aipp,lq,kωplk Qp1 ωplkq, @p P P, @l P Lp,@k P Bipp,lqzt0u (50) φplk ¤ paipp,lq,k aipp,lq,k1qωplk, @p P P, @l P Lp,@k P Bipp,lqzt0u (51) ¸ kPBipp,lqzt0u ωplk ¥ xp, @p P P, @l P Lp (52) ωplk ¤ xp, @p P P, @l P Lp,@k P Bipp,lqzt0u (53) opl qpl ¸ kPBipp,lqzt0u φplk, @p P P, @l P Lp (54) ∆pl ¸ kPBipp,lqzt0u φplk{ρilk, @p P P, @l P Lp (55) ¸ iP rVzt0u,ij ¸ pPPij τp ¸ iPV,ij ¸ pPPij tpx p ¸ lPLp p∆pl ∇plq pj ¸ lP rV ,lj ¸ pPPjl τp, @j P I (56) τp ¸ lPLp p∆pl ∇plq ¤ Tmax tp pdppq tdppq,0 xp, @p P P (57) τp toppq,ipp,0qxp ∇p0 sp0, @p P P (58) dp,l1 tipp,l1q,ipp,lqxp ∇pl spl, @p P P, @l P Lp, l 0 (59) ∆pl dpl spl, @p P P, @l P Lp (60) xpP t0, 1u, @p P P (61) τp¥ 0, yp¥ 0 @p P P (62) qpl, opl, spl, dpl, ∆pl, ∇pl¥ 0, @p P P, @l P Lp (63) φplk ¥ 0 @p P P, @l P Lp,@k P Bipp,lqzt0u (64) ωplk P t0, 1u @p P P, @l P Lp,@k P Bipp,lqzt0u (65)
Equation (42) gives the objective of the problem: minimizing the total time (driving times, service times, and charging times). Constraints (43) ensure that each customer is visited once. Constraints (44) impose the flow conservation. Constraints (45) track the SoC of EVs at each customer. Constraints (46) track the SoC at the arrival at the first CS of each recharging path. Constraints (47) couple the SoC of an EV that leaves a CS to go to another CS. Constraints (48) ensure that if the EV travels between a vertex and the depot, it has sufficient energy to reach its destination. Constraints (49) couple the SoC tracking variable to the arc travel variables. Constraints (56) track the departure time at each vertex. (57) couple the time tracking variable to the arc travel variables, and impose the tour duration limit. Constraints (50) restrict the segments on which EVs can charge according to the state of charge they have at their arrival at CSs. Constraints (51) restrict the charging amount that can be charged on each segment. Constraints (52) impose the activation of one segment whenever an EV visit a CS. Constraints (53) are valid inequalities. Constraints (54) define the SoC of an EV after a charging operation. Constraints (55) define the time spent charging at each CS. Finally, constraints (61)–(65) define the domain of the
decision variables.
It is worth noting that other authors have proposed recharging path-based formulations for closely related problems. For instance Andelmin (2014) proposed a refueling path-based model for the G-VRP. However, his model greatly differs from ours because the author used node tracking variables and the problem contains several simplifying hypothesis: a full charging policy and a linear approximation of the charging function.
For each visit to a CS in a path of set P , we associate a charging operation o P O. Every charging operation o corresponds to the visit of the CS at position lo in a path
that we denote po. Let Oi the set of charging operations at CS i P F . Sequential binary
variable uoo1 is equal to 1 if and only if charging operation o1 is constrained to start after
the completion of charging operation at o. For every CS i P F , we denote εi and εi be two dummy charging operations (acting as the source and the sink of the flow). Let po, o1q P O
i Y tεi u
OiY tεi u
be a couple of charging operations, continuous flow variable foo1 denotes the quantity of resource that is transferred from charging operation o
to charging operation o1. For notational convenience, we define rCo : 1 for all o P Oi and
r Cε
i : rCεi : Ci. A flow-based formulation of the capacity constraints for rP
paths is as follows: ¸ o1POiYtεiu fo1o xpo @i P F, @o P Oi (66) ¸ o1POiYtε iu fo1o ¸ o1POiYtε iu foo1 0, @i P F, @o P Oi (67) Ci ¸ oPOiYtεiu fε i,o 0, @i P F (68) ¸ oPOiYtεiu fo,ε i Ci 0, @i P F (69) spo,lo dpo1,lo1 ¥ Tmaxpuo1o 1q , @i P F, @o, o 1 P O i (70) foo1¤ minp rCo, rCoquoo1, @i P F, @po, o1q P OiY tεi u OiY tεi u (71) uoo1P t0, 1u, @i P F, @o, o1 P Oi (72) foo1¥ 0 @i P F, @po, o1q P OiY tεi u OiY tεi u (73)
Alternatively, to model the capacity constraints, an event-based formulation or one of the continuous formulations introduced by Kopanos et al. (2014) could be used. Some preliminary experiments revealed that those formulations are intractable (even for small instances) because they rely on a large number of binary variables and constraints. We therefore decided to abandon that path.
4. A two-stage solution method
It is known that directly solving MILP formulations is usually computationally in-tractable for medium-sized and especially for large-sized instances. The results in Froger
et al. (2017) confirm the limitation of MILP solvers to provide good-quality solutions to the E-VRP-NL in a reasonable amount of time even for small instances (up to 20 customers). To tackle the E-VRP-NL-C we propose a route-first assemble-second approach. The first stage of our matheuristic intends to build a high-quality and diverse pool Ω of routes. The second stage assembles solutions by selecting a subset of routes from the pool Ω. This two-stage method has been successfully applied to several hard vehicle routing problems (VRPs): the VRP with time windows (Alvarenga et al., 2007), the truck and trailer routing problem (Villegas et al., 2013), the Swap-Body VRP (Absi et al., 2015), the E-VRP-NL (Montoya et al., 2017). Traditionally, the second phase builds the best possible solution by solving a set partitioning (SP) model over the pool of routes. Route-first, assemble-second approaches have been mostly applied to problems without route coupling constraints. The latter means that in those problems the feasibility of one route is totally independent of the feasibility of other routes. Due to the CS capacity constraints, clearly the E-VRP-NL does not fall into this category. To the best of our knowledge, only two studies have dealt with RFAS approaches for VRPs with route coupling constraints: Morais et al. (2014) and Grangier et al. (2017) as an intensification phase of a metaheuristic for the VRP with cross docking. In both cases, the cross-dock constraints are relaxed in the SP model. Each time the SP model finds a new better solution Morais et al. (2014) applied a local search to make it meet the cross-dock constraints, whereas Grangier et al. (2017) used a constraint programming model to check its feasibility.
We first propose to relax the CS capacity constraints during the first stage and to adapt the set partitioning model of the second stage to take the limited numbers of chargers at CSs into account.
4.1. First stage: an iterated local search
The first phase of the matheuristic builds a pool of routes that meet the constraints 2, 3, and 4 described in Section 2 (i.e. all the constraints that need to be satisfied for a route are satisfied, except the CS capacity constraints). To generate these routes, we use the approach proposed by Montoya et al. (2017) for the E-VRP-NL. These authors designed an iterated local search (ILS) initialized with a solution provided by a constructive heuristic. The metaheuristic first sequences the customers and then takes the charging decisions. Specifically, at each iteration of the local search, the method builds a giant tour by concatenating the routes in the current solution. Then, it applies a small perturbation to the tour based on a randomized double bridge operator. Afterwards, it applies a splitting procedure to create a feasible solution to the problem. The split procedure works on an acyclic graph where nodes are customers and there exists an arc between two nodes if there exists a route where the first and the last visited customers are the origin and the tail of the arc, respectively. The procedure repairs energy-infeasible routes using a heuristic procedure that considers the insertion of one CS between each pair of customers. Solving a shortest path problem in the above graph leads to a feasible solution to the E-VRP-NL. To improve this latter, a local search is applied. This search uses two classical operators focusing on sequencing decisions: two-opt and relocate (intra-route and inter-route versions with best improvement selection). A third operator revises the charging decisions using a
MILP model. During the procedure, all the local optimum solutions are stored in a pool Ω. It is noteworthy that in all the routes in Ω do not have any waiting time (i.e. charging operations are left-shifted). Moreover, the charging decisions inside each route are already optimized.
4.2. Second stage: a decomposition method to assemble the routes
The second stage of the matheuristic builds the best possible solution from Ω. We proposed to assemble solutions using a Benders’ like decomposition of the problem into a route selection master problem and a CS capacity management sub-problem. The master problem consists in selecting a set of routes such that every customer is covered exactly by one route. Every selection of routes (output of the route selection problem) yields a set of charging operations; each operation being defined by a CS, a starting time, and a recharge amount. The sub-problem checks if the CS capacity constraints can be met. We proposed three different versions of this CS capacity management sub-problem depending to the degree of freedom that we allow to modify the routes selected as a solution to the master problem. In the a first strategy, we do not revise the charging decisions (starting time and recharging amount) in the routes selection and we only check if the CS capacity constraints are satisfied for the selected routes. In the second strategy, we can delay the charging operations (i.e. postpone their starting time) to satisfy the CS capacity constraints. In other words, contrary to the first strategy, here we allow vehicles to wait for a charger if a CS is overcrowded. In the third strategy, in addition to the introduction of waiting times, we also revise the recharging amounts, but not the visited CSs.
To efficiently solve the problem while exploiting this decomposition, we adopt the fol-lowing approach implemented on top of a commercial solver. We solve the SP model related to the route selection problem using a branch-and-bound algorithm. At each integer node of the branch-and-bound tree, the corresponding solution is sent to the CS capacity man-agement problem. In the three strategies, we introduce cuts to discard infeasible selection of routes. In the two last strategies we also add cuts to account for the additional waiting times potentially introduced. Contrary to the classical implementation of Benders decompo-sition, we dynamically generate cuts in the branch-and-bound tree used to solve the initial relaxed master problem. More specifically, at each integer node of the branch-and-bound tree, the corresponding solution is sent to the sub-problem in order to potentially generate the Benders cuts. This method is referred to as a Benders-based branch-and-cut algorithm in (Naoum-Sawaya and Elhedhli, 2010) or as a branch-and-Benders-cut method in (Gen-dron et al., 2014). It also shares a lot of similarities with the Branch&Check framework – introduced by Thorsteinsson (2001) – and originally designed for linear and constraint programming (CP) hybridization.
In the following subsections, we provide a detailed description of our three strategies. We use the following notation. Set Ωi Ω contains the routes serving customer i P I and tr is
the duration of a route rP Ω. Set OpΩq contains all the charging operations occurring in the routes belonging to Ω and OipΩq contains the charging operations occurring at CS i P F . Let
¯
∆poq, ro, and io be the duration, the route, and the CS associated with charging operation
oP OpΩq. We define symbols ¯Spoq and ¯Cpoq as the original starting and completion time of charging operation o in the route ro of the pool Ω.
4.2.1. First strategy
In the first strategy, we do not revise the charging operations involved in the routes built during the ILS stage. Let us first define a MILP model for the route selection problem. We introduce binary variable xr that is 1 if and only if route r P Ω is selected. The MILP
formulation is then the following classical SP model:
rHC1s min¸ rPΩ trxr (74) ¸ rPΩi xr 1, @i P I (75) xrP t0, 1u, @r P Ω (76)
The objective (74) is to select the subset of routes from Ω that minimizes the total duration. Constraints (75) ensure that each customer is visited exactly once. Constraints (76) set the domain of the decision variables.
We now assume that we have a fixed selection Ωp¯xq of routes given by fixing the variables txrurPΩ. Specifically, we have Ωp¯xq tr P Ω|¯xr 1u. Let SHC1p¯xq be the resulting
CS capacity management problem that consists in checking the feasibility of the charging operations at every CS. SHC1p¯xq can be decomposed into |I| independent problems, one for every CS. Let define Oip¯xq OipΩq as the set of charging operations occurring at CS i P F
in the routes of Ωp¯xq. To solve SHC1p¯xq, we apply procedure CheckCapacityCut(Oip¯xq, Ci)
for every CS i P F to check the existence of subsets of operations overloading the CS. If the set returned by this procedure is non-empty, there exists one or multiple time intervals during which the number of EVs charging at i is strictly greater than Ci.
To discard the current solution ¯x in the route selection sub-problem, we add the following cuts torHC1s:
¸
rPΨipΩp¯xq,Uq
xr ¤ Ci @i P F, @U P U (77)
where ΨipΩp¯xq, Uq tr P Ωp¯xq|OrX U Hu.
These cuts simply state that the number of selected routes (according to ¯x) that have charging operations that overlap at a specific CS must be less than or equal to the number of chargers available at this CS.
We can also imagine to separate cuts for continuous solution ¯x. In that case, we check the satisfaction of the CS capacity constraints by simply considering that for every CS i every operation o P Oip¯xq requires a fractional number ¯xro of chargers. Another strategy is to consider only the routes r such that ¯xr 1. In our experiments, this latter strategy
proves to lead to the best results.
Procedure CheckCapacityCut(O,C)
input : - a list of charging operations L numbered from 1 to n (Lpiq denotes the operation at position i in the list L)
- an integer number C ¥ 1 representing the maximum number of operations that can be scheduled simultaneously
output: a set containing all the maximal subsets of charging operations leading to a violation of the CS capacity constraint
1 Sort the operations in L in non-decreasing order of starting time
2 U Ð H
3 U Ð tLp1qu
4 k Ð 2
5 excessÐ false 6 while k ¤ n do
7 for every operation oP U do 8 if ¯SpLpkqq ¥ ¯Cpoq then 9 if excess then 10 U Ð U Y tUu 11 excessÐ false 12 end 13 U Ð Uztou 14 end 15 end 16 U Ð U Y tLpkqu 17 if |U| ¡ C then 18 excessÐ true 19 end 20 end 21 if excess then 22 U Ð U Y tUu 23 end 24 return U
4.2.2. Second and third strategies
One possible drawback of the first strategy is that it may reject solutions that could be repaired by simply allowing the EV to wait a few minutes for a charger. As mentioned earlier, the second and third strategies consider the possibility of introducing waiting times before the charging operations. Delaying a charging operation in a route r P Ω necessarily increases the duration of the route. Therefore, allowing the introducing of waiting times when solving the CS capacity management sub-problem may change the objective function of the solution computed when solving the route selection problem. Let θ be a non-negative variable estimating the delay added when solving the CS capacity management sub-problem.
A MILP formulation of the route selection problem (derived directly from rHC1s) follows: rHC2s min¸ rPΩ trxr θ (78) ¸ rPΩi xr 1, @i P I (79) θ¥ 0 (80) xrP t0, 1u, @r P Ω (81)
Given a solution ¯x ofrHC2s, we define Ωp¯xq as the set of routes r selected according to ¯x (i.e. Ωp¯xq tr P Ω|¯xr 1u). We also define Ωp¯xq as the subset of Ωp¯xq that contains only
the routes including at least one charging operation (i.e. Ωp¯xq tr P Ωp¯xq|Oprq Hu). For convenience, we denote as Oprq the list of charging operations occurring in route r. We assume that the operations in Oprq are sorted in non-decreasing order of their starting times. We denote as πpoq and π poq the charging operations preceding and following o in route ro.
If no charging operation precedes or follows before or after o, we set πpoq π poq 1. For every route r P Ωp¯xq and for each charging operation o P Oprq in a route we denote as t poq the travel time of the EV between the completion of o and the start of π poq if o is not the last operation of the route or the arrival at the depot. More specifically, this time corresponds to the total time spent by the vehicle covering its route between the CS associated with o and the CS associated with pi poq or the depot. Similarly, we define as tpoq the time elapsed between the EV’s departure from the depot (if o is the first operation of the route) or the completion of πpoq and the beginning of o. We denote as Πpoq and Π poq the set of charging operations preceding and following charging operation o.
Second strategy: Let SHC2p¯xq be the problem where we want to schedule – while considering the capacity of the CSs – the charging operations occurring in the routes Ωp¯xq in order to minimize the addition of waiting times. Contrary to SHC1p¯xq, SHC2p¯xq does not decompose into an independent problem for each CS. For each operation o, we introduce two parameters ESo and LSo representing its earliest and latest possible starting time. The
parameter ESo is equal to ¯Spoq since by definition the operations are left shifted in each
route of the pool. The parameter LSo is computed by subtracting to Tmax the time needed
to complete the route (considering the duration of the next operations, the driving times, and no waiting times). Specifically LSo Tmax ¯∆poq t poq
°
o1PΠ poqpt po1q ∆¯po1qq.
A MILP formulation of SHC2p¯xq requires several types of decision variables. We define the continuous variable So defining the starting time of operation o. We model the capacity
constraints using a flow-based formulation. For each CS i P F , we consider two dummy operations εi and εi , and we define rCo : 1 for all o P Oip¯xq and rCεi : rCεi : Ci. We
then introduce continuous variable foo1 representing the quantity of resource (i.e. chargers)
that is transferred from charging operation o to charging operation o1. We also define the sequential binary variable uoo1 taking the value of 1 if operation o is processed before activity
o1. A MILP formulation of SHC2p¯xq reads:
rSHC2p¯xqs min ¸ rPΩp¯xq s.t. OprqH Solast r ESolastr (82) uoo1 uo1o¤ 1 @i P F, @o, o1 P Oip¯xq : o o1 (83) uoo2 ¥ uoo1 uo1o2 1 @i P F, @o, o1, o2P Oip¯xq (84)
So1 So¥ ¯∆poquoo1 pLSo ESo1qpuoo1 1q @i P F, @po, o1q P Oip¯xq Y tεiu
Y Oip¯xq Y tεi u
(85) Sπ poq So¥ ¯∆poq t poq @r P Ωp¯xq, @o P Oprq : π poq 1 (86)
¸ o1POip¯xqYtεiu fo1o 1, @i P F, @o P Oip¯xq (87) ¸ o1POip¯xqYtεiu fo1o ¸ o1POip¯xqYtεiu foo1 0, @i P F, @o P Oip¯xq (88) Ci ¸ oPOip¯xqYtεiu fε i,o 0, @i P F (89) ¸ oPOip¯xqYtεiu fo,ε i Ci 0, @i P F (90) foo1 ¤ max Co, Co1 uoo1 @i P F, @o, o1 P Oip¯xq (91) ESo¤ So¤ LSo @i P F, @o P Oip¯xq (92) foo1 ¥ 0 @i P F, @po, o1q P Oip¯xq Y tεiu Y Oip¯xq Y tεi u (93) uoo1 P t0, 1u, @i P F, @o, o1 P Oip¯xq (94)
The objective (82) is to minimize the waiting time inserted in each route (olastr represents the last charging operation of route r). Constraints (83) state that for two distinct operations o and o1, either o precedes o1, o1 precedes o, or o and o1 are processed in parallel. Constraints (84) express the transitivity of the precedence relations. Constraints (85) are the disjunctive constraints on the operations related to the same CS. The constraint is active when uoo1 1
and, in that case, it enforces the precedence relation between charging operations o and o1. Constraints (86) enforce the precedence relation and the time lag between the charging operations occurring in the same route. Constraints (87) state that a charger has to be allocated to each charging operation. Constraints (88)-(90) ensure the flow conservation. Constraints (91) couple the flow variables to the sequence variables. Constraints (92) and (94) define the domain of the decision variables.
To reduce the size of the previous model, we applied the following procedure. For every CS i and every couple of operationspo, o1q P Oip¯xq2, we created only the variables uoo1 and foo1
if the charger used by operation o can be transferred to operation o1(i.e., ESo ∆¯poq ¤ LSo1).
One can notice that SHC2p¯xq is a particular parallel machine scheduling problem where the objective is to minimize the total tardiness. Indeed, one can see ESo as the release date
of each charging operation o and ESo ∆¯poq as its due date if o if it is the last operation of
route ro (the due date is equal to LSo ∆¯poq otherwise). The particularity of SHC2p¯xq is
that there is a minimum time lag between charging operations of the same route. Moreover, 17
the last charging operation of the route is late if it does not start exactly at its release date. Third strategy: In addition to the introduction of waiting times, reducing congestion at CSs can come from the revision of the amounts of energy charged at each CS in every route. For example, if an EV leaves a CS i not fully charged and visits another CS j in the route, one can decide to charge more at CS i to delay the arrival of the EV at j if this latter is overcrowded. Alternatively, one can decide to charge more at CS j (if possible) to reduce the time spent at CS i. Let p¯xrqrPΩ be a fixed selection of routes (resulting in Ωp¯xq), we
denote SHC3p¯xq the sub-problem where we want to minimize the increase in the duration of the selected routes.
We denote as epoq the energy consumption of the EV from its departure from io to its
arrival at iπ poq if o is not the last charging operation of ro or its arrival at the depot. This
takes into account the energy consumed to visit all the customers scheduled in the route between charging operations o and π poq or the depot. Similarly, we denote as e poq the energy consumption of the EV from its departure from iπpoq if o is not the first charging
operation of the route or from the depot to its arrival at io. Since a charging operation can
be skipped by shifting energy to previous or next charging operations of the same route, we define rtpoq and repoq as the time and energy saved if the EV does not detour to perform the charging operation o.
Our modelization of SHC3p¯xq draws very broadly on the formulation rSHC2p¯xqs. We therefore use the decision variables So, foo1, uoo1 defined in this latter formulation. Let i be
a CS. First, we introduce binary variable zo that is 1 if and only if the charging operation
o P Oip¯xq is not executed anymore and the detour to the corresponding CS is not needed
anymore. Specifically, zo allows to account for special cases where shifting the charging
amount to the other operations of the route can avoid charging operation o. To evaluate the impact of the revision of the charging operations, we introduce for each route r P Ωp¯xq a continuous variable Tr that is the new duration of route r. We model the piecewise linear
approximation of the charging function as in the formulation presented in Section 3. Let o be a charging operation and k P Bizt0u. We define continuous variable φok as the amount
of energy charged during o on the segment that lies between the points pci,k1, ai,k1q and
pcik, aikq k P Bi. We also define the binary variable ωok that is equal to 1 if and only if during
the charging operation o the EV charges on the segment between the points pci,k1, ai,k1q
and pcik, aikq. We introduce continuous variables yo1 and y2o that represent the SoC of the
EV before and after charging operation o. Let AEmin
o and AEomax be the minimum and
maximum possible SoC before the beginning of o. The value of AEmin
o and AEomax are
set considering that the EV charges the minimum (the maximum between the energy to reach the current CS and the energy needed for the detour) and maximum (the EV left the previous CS fully charged or with the energy necessary to finish the route) amount of energy at the previous CSs (if any). Similarly, let DEomin and DEomax be the minimum and maximum possible SoC after the completion of o. The value of DEmin
o corresponds either to
the maximum between the energy to reach the next CS if any or the depot and the energy remaining after leaving the depot fully charged and visiting the previous customers and CSs in the route. The value of DEmax
o is the minimum between the energy that is needed to
finish the route after o and the battery capacity Q. A MILP formulation of SHC3p¯xq reads: rSHC3p¯xqs min ¸ rPΩp¯xq s.t. OprqH pTr trq (95) y1o φok ¤ aikwok Qp1 wokq, @i P F, @o P Oip¯xq, @k P Bizt0u (96) φok ¤ paik ai,k1qwok, @i P F, @o P Oip¯xq, @k P Bizt0u (97) ¸ kPBizt0u wok ¥ 1, @i P F, @o P Oip¯xq (98) y2o yo1 ¸ kPBizt0u φok, @i P F, @o P Oip¯xq (99) ∆o ¸ kPBizt0u φok{ρik, @i P F, @o P Oip¯xq (100) ∆o¤ cibip1 zoq, @i P F, @o P Oip¯xq (101)
y1π poq y2o e poq repoqzo @r P Ωp¯xq, @o P Oprq, π poq 1 (102)
y2olast r e po last r q repo last r qzolast r ¥ 0 @r P Ωp¯xq (103) uoo1 uo1o¤ 1 @i P F, @o, o1P Oip¯xq : o o1 (104) uoo2 ¥ uoo1 uo1o2 1 @i P F, @o, o1, o2P Oip¯xq (105) So1 So¥ ∆o pESo1 LEoqp1 uoo1q @i P F, @o, o1P Oip¯xq (106)
Sπ poq So¥ ∆o t poq rtpoqzo @r P Ωp¯xq, @o P Oprq, π poq 1 (107)
¸ o1POip¯xqYtε iu fo1o 1 zo, @i P F, @o P Oip¯xq (108) ¸ o1POip¯xqYtεiu fo1o ¸ o1POip¯xqYtεiu foo1 0, @i P F, @o P Oip¯xq (109) Ci ¸ oPOip¯xqYtεiu fε i,o 0, @i P F (110) ¸ oPOip¯xqYtεiu fo,ε i Ci 0, @i P F (111) foo1¤ max Co, Co1 uoo1 @i P F, @o, o1P Oip¯xq (112) Tr Solast r ∆olastr rtpo last r q t po last r q @r P Ωp¯xq, (113) Tr¤ Tmax @r P Ωp¯xq, (114) ESo¤ So¤ LEo @i P F, @o P Oip¯xq (115) AEomin¤ y1o¤ AEomax @i P F, @o P Oip¯xq (116) DEomin¤ yo2¤ DEomax @i P F, @o P Oip¯xq (117) φok ¥ 0 @i P F, @o P Oip¯xq, @k P Bizt0u (118) wok P t0, 1u @i P F, @o P Oip¯xq, @k P Bizt0u (119) foo1¥ 0 @i P F, @po, o1q P Oip¯xq Y tεi u Y Oip¯xq Y tεi u (120) uoo1P t0, 1u, @i P F, @o, o1P Oip¯xq (121) zoP t0, 1u, @i P F, @o P Oip¯xq (122) Tr¥ 0, @r P Ωp¯xq (123) 19
The objective (95) is to minimize the additional time inserted in each route. Constraints (96)-(100) model the piecewise linear approximation of the charging function. Constraints (101) impose a duration equal to 0 for each charging operation that is removed (Smax is
the maximum possible charging time in any CS of F ). Constraints (102) couple the SoC of the EV after finishing a charging operation with its SoC when starting the next charging operation occurring in the route. Notice that if zo is equal to 1, then the SoC yo1 y2o still
takes into account the energy consumed to detour to CS io. The energy saved by not visiting
this CS is subtracted when computing the SoC at the beginning of the next operation of the route or at the arrival at the depot (see (103)). For each route, constraints (103) enforce the corresponding EV to have enough SoC at the end of the last charging operation to reach the depot. Constraints (104), (105), and (106) define the precedence relationships between the operations. Constraints (107) enforces the precedence relation and the time lag between the charging operations occurring in the same route. Notice that if zo is equal to 1, then the
starting time So still takes into account the detour to CS io. The time saved by not visiting
this CS is subtracted during the computation of the departure time for the next operation of the route or at the arrival at the depot (see (114)). Constraints (108) set if a charging operation requires a charger or not. Constraints (109) - (112) define the flow constraints. Constraints (113) compute the duration of each route. Constraints (114) enforce the tour duration limit. Constraints (115) and (122) define the domain of the decision variables.
Cut generation: The efficiency of the approach is primarily based on the constraints we generate to cut off infeasible solutions and to bound the variable θ.
When the CS capacity management sub-problem (SHC2p¯xq or SHC3p¯xq) is infeasible, we generate an integer Benders cut, also called combinatorial Benders cuts (Codato and Fischetti, 2006) to invalidate the current solution to the restricted master problem. Let C be the set of indices of the variables x restricted to be binary and x the current solution to the restricted master problem. Denoting Ωp¯xq tr P Ω|¯xr 1u, a combinatorial Benders
cut can be defined as follows: ¸ rPΩzΩp¯xq xr ¸ rPΩp¯xq p1 xrq ¥ 1 (124)
Clearly, this cut states that at least one of the variables of the master problem must change its value with respect to the current solution ¯x. This cut is also known as a no-good cut. Since every selection of routes ¯Ω such that Ωp¯xq ¯Ω also leads to an infeasible solution, we can reformulate the cut (124) as follows:
¸
rPΩp¯xq
xr ¤ |Ωp¯xq| 1 (125)
If the sub-problem is feasible, we compare the value of θ (denoted ¯θ) to the sub-problem objective value denoted zSPp¯xq. If the objective value of the sub-problem is underestimated (i.e. ¯θ zSPp¯xq), we generate integer optimality cuts to ensure that the value of the variable
θ is larger than or equal to the value of the sub-problem for the current selection of routes. Specifically, we add the following cut:
zSPp¯xq ¸ rPΩp¯xq xr ¸ rPΩzΩp¯xq xr zSPp¯xq p|Ωp¯xq| 1q LB ¤ θ (126)
These cuts are similar to those introduced by Laporte and Louveaux (1993) for the integer L-shaped method. Since every selection of routes ¯Ω such that Ωp¯xq ¯Ω leads to a solution with a larger objective value, we can reformulate the cut (126) as follows:
zSPp¯xq 1 ¸ rPΩp¯xq xr |Ωp¯xq| ¤ θ (127)
In order to produce stronger cuts, it is noteworthy that the sub-problem may often be decomposed into several independents smaller sub-problems. Let Gp¯xq be a graph where each node represents a CS and there exists an edge between 2 CSs if there exists a route in Ωp¯xq with charging operations at these 2 CSs. Let ΥpGp¯xqq be the connected components of graph Gp¯xq. The sub-problem can be decomposed into an independent problem for each connected component υ P ΥpGp¯xqq (where we consider only the routes with charging operations associated with CSs in υ). Let Ωp¯x, υq Ωp¯xq be the routes visiting the CSs that are part of υ. We can strengthen the cut (125) by replacing it by the following cuts:
¸
rPΩp¯x,υq
xr¤ |Ωp¯x, υq| 1 @υ P ΥpGp¯xqq (128)
Quite similarly, we can strengthen the cut (127) by replacing it by the following cuts: ¸ υPU zSPp¯x, υq 1 ¸ υPU ¸ rPΩp¯x,υq xr |Ωp¯x, υq| ¤ θ @U P P pΥpGp¯xqqq ztHu (129) Notice that the number of these cuts can become large. In that case, we can generate the cuts (129) only for the sets U such that|U| 1 or U ΥpGp¯xqq.
4.2.3. Implementation details
From an implementation point of view, we start the second stage by simply forwarding the formulation rHC1s or rHC2s to the MILP solver. The cut generation procedure is implemented inside a callback routine that is invoked by the solver at every node of the branch-and-bound tree. The cuts computed during this stage are provided to the solver as lazy constraints if the node is integer or as classical cuts otherwise. After adding them at a node, the solver also checks the feasibility of the solutions in terms of these constraints. If the candidate solution is not feasible, the solver discards it and adds the violated lazy constraints or cuts to the active nodes of the branch-and-bound tree.
5. Computational results
We tested the different models developed for the E-VRP-NL-C. We used Gurobi 7.0.2 to solve the ILP models through its Java API. All experiments were performed, using a single thread with 12 GB, on a cluster of 27 computers, each of which having 12 cores and two Intel(R) Xeon X5675 3.07 GHz processors. We set a 3-hour time limit (the CPU timesR
are reported in seconds and rounded to the nearest integer). We performed our tests on 100 instances adapted from the 120-instances testbed proposed by Montoya et al. (2017) (we adapted only the instances that contained at most 160 customers). We adapted each instance by fixing a number of chargers for each CS. We decided to consider instances in which all the CSs have the same number of chargers (1, 2, or 3). We penalized the waiting time in the objective using K 1.
5.1. Mixed integer linear programming formulations
In order to assess the performance of the proposed MILP formulations, we performed our tests on small-sized instances. We restrict our tests on the 20 instances of the 120-instances testbed proposed by Montoya et al. (2017) that contains 10 customers. For CS replication-based models, the number of copies of each CS i P F is set to β P rCi 1, 8rXN (i.e.
βi β, @i P F ). We assume in our tests that in every instance each CS has only one charger
(i.e. Ci 1, @i P F ). Adapting the terminology used in (Froger et al., 2017), we refer to each
model via “a b c” where a, b, and c refer to the modeling of the SoC and time tracking (A: arc-based tracking constraints), of the charging function (C: CB piecewise linear constraints / R: R piecewise linear constraints), and of the CS capacity constraints (F: flow-based / E: event-based). If the formulation uses the concept of recharging path, we add the prefix “Path”. The baseline formulations rFCSs and rFpaths correspond to notation “A R” and “Path A R”. We refer the reader to (Froger et al., 2017) for the detailed explanations of formulations “A C” and “Path A C”.
Table 1 present the results of the direct solution of the MILP formulations. Specifically, Table 1a and Table 1b show the results obtained when running CS-replication based and recharging path-based formulations on the MILP solver. See AppendixC for the detailed results for each instance. We report for each formulation and each value of β the number of instances optimally solved to the number of instances with a feasible solution (#Opt/#Feas), the average solution time for the instances solved to optimality (Time), and the average gap for the unsolved instances (Gap). We compute the gappz zLBq{z where z is the objective of the computed solution and zLB is the lower bound retrieved by the solver running the
corresponding model. Moreover, since average values do not provide sufficient information, Figure 4 and Figure 5 show the number of instances optimally solved according to the solution time for all the formulations we tested.
First, we observe that, on the considered instances, the modeling of the charging func-tion and the capacity constraints has very little impact on the results. Second, results tend to show the difficulty to optimally solve even small instances running MILP solver on CS replication-based and recharging path-based formulations. If we compare these results
Table 1: Computational results of the different models β A C E A C F A R E A R F 2 #Opt/#Feas 15/15 15/15 15/15 15/15 Temps (s) 486 861 131 807 3 #Opt/#Feas 18/20 18/20 19/20 17/20 Temps (s) 764 801 1048 959 Gap 8.6% 9.8% 7.2% 9.9% 4 #Opt/#Feas 16/20 16/20 17/20 16/20 Temps (s) 414 719 853 764 Gap 10.9% 13.0% 12.7% 12.8%
(a) CS-replication based formulations
Path A R F Path A C F #Opt 14/20 16/20 Temps (s) 1468 493 Gap 15.7% 19.4%
(b) Recharging paths-based formulations
with those obtained by Froger et al. (2017) for the E-VRP-NL, the addition of the CS ca-pacity constraints makes more complex solving the recharging-paths formulations (all the 10-customer instances are optimally solved when dropping these constraints in less than 10 minutes on average). Finally, MILP solver tends to perform slightly better on the path-based models rather than on the classical models based on the replication of the CS nodes.
(a) β 3 (b) β 4
Figure 4: the different CS replication-based formulations for different values of β
Figure 5: the different recharging path-based formulations
5.2. Two-stage algorithm
Since our contributions are solely focused on the second stage of the matheuristic, we focus our experiments only on this stage. We tested the different strategies presented in Section 4.2. For these strategies, we tested two different cutting schemes: only at every integer node (C1) or at every node1(C2). We report in Table 2 the results obtained when using Strategy 1, Strategy 2, or Strategy 3. We also conducted another test (Strategy 4 -Post-processing) in which we solve the second stage in two steps: (1) we solve the SP model rHC1s without taking the capacity constraints into account, yielding an optimal solution ¯
x, and then (2) if ¯x violates the capacity constraints, we solve the model rSHC3p¯xqs to potentially repair it. For each value of the capacity (1, 2, and 3), we report the number of instances for which we obtained a feasible solution (#Feas), the number of best known solution reported (#BKSs), and the average solution time (Time). Notice that the solution time reported takes only the second stage of the matheuristic into account. For a meaningful comparison, we report two different gaps: the gap to the best known solutions considering only the instances for which the solution is different from the BKS (Gap) and the gap to the BKSs considering all the instances (Gap). We also show the number of feasibility (#Cuts Feas) and optimality (#Cuts Opt) cuts generated by the algorithm.
First, if the capacity constraints are not binding, it is not very surprising to see that all the different strategies yield very similar results. We observe that Strategy 4 (and to a less extend Strategy 1) do not always provide a feasible solutions to the e-VRP-NL-C. This show the relevance of our Benders’ like decomposition algorithm. Checking only the capacity constraints in a third stage could either lead to infeasibility or to worst solutions. For one instance we do not obtain a feasible solution by any of our strategies. It points out the potential need for taking the capacity constraints into account during the first stage of the algorithm. Results show that allowing delays when solving the CS capacity management sub-problem (Strategy 2 and 3) is the most suitable and efficient approach to assemble solutions in the second stage of the matheuristic. In our tests, it can be noticed that it is
1In the sub-problem, we only consider the routes r such that ¯x r 1
Table 2: Computational results according to the strategy used for the second stage of the matheuristic
Capacity Strategy 1 Strategy 2 Strategy 3 Strategy 4 C1 C2 C1 C2 C1 C2 Post-processing 1 #Feas 97 97 99 99 99 99 90 #BKS 83 83 95 95 99 99 77 Time (s) 23 20 6 5 6 5 2 Gap 0.24% 0.24% 0.02% 0.02% - - 0.12% Gap 1.65% 1.65% 0.41% 0.41% - - 0.82% #Cuts Feas 20.2 27.2 9.4 8.5 4 2.4 -#Cuts Opt - - 32 26 38.1 30.3 -2 #Feas 99 99 99 99 99 99 99 #BKS 97 97 99 99 99 99 97 Time (s) 3 3 3 3 2 2 2 Gap 0.01% 0.01% - - - - 0.01% Gap 0.29% 0.29% - - - - 0.42% #Cuts Feas 0.5 0.7 0.1 0.1 0 0 -#Cuts Opt - - 0.7 0.6 0.7 0.7 -3 #Feas 100 100 100 100 100 100 100 #BKS 100 100 100 100 100 100 100 Time (s) 3 2 2 3 2 2 2 #Cuts Feas 0.1 0.1 0 0 0 0 -#Cuts Opt - - 0.3 0.3 0.3 0.3
-not more computationally expensive than just checking the CS capacity constraints. When all CSs have a unique charger, compared to Strategy 1, using Strategy 2 and 3 improves the BKs for 12 and 14 instances out of 99, respectively. Moreover, the gap can be quite important (up to almost 15% for one instance). Last but not least, although revising the charging amounts improves only slightly the results, results show that using Strategy 3 is the best assembling method on the considered instances.
To allow future comparisons with our method, we report detailed results for each of the 120 instances in AppendixC.
6. Conclusion and perspectives
In this research, we have extended the E-VRP-NL by introducing capacity constraints at CSs. In the resulting problem (E-VRP-NL-C), the number of vehicles simultaneously charging at every CS is limited by the number of chargers.
We have introduced two modeling approaches of these constraints (flow-based and event-based). Based on this, we have proposed several CS replication-based and recharging path-based formulations of the E-VRP-NL-C. Results show that optimally solving small-sized instances is already challenging.
To tackle the E-VRP-NL-C, we have proposed a two-stage matheuristic. During the first stage, we build a set of routes using an existing metaheuristic based on iterated local search. During the second stage, we assemble these routes to build a solution to the problem using a Benders’ like decomposition method. While solving the route selection problem, we consider the capacity constraints at the nodes of the branch-and-bound tree. We discard
infeasible solutions or solutions for which the objective is underestimated using cuts. We have investigated three different versions of the CS capacity management problem ranging from a simple check of the capacity constraints to the introduction of waiting times to the revision of the charging amounts in the selected routes. Results show that using more complex strategies to solve bottleneck issues at CSs does not increase on the considered instances the solution time while leading to better solutions. Results also show that the algorithm finds some optimal solutions for small-sized instances.
Future works include the revision of the first stage to include the capacity constraints and to generate routes that can be better assembled. Finally, it might be interesting to investigate if the two-stage method can provide an efficient heuristic framework to solve routing problems where dependency arise between routes.
References
Absi, N., Cattaruzza, D., Feillet, D., and Housseman, S. (2015). A relax-and-repair heuristic for the swap-body vehicle routing problem. Annals of Operations Research, pages 1–22.
Alvarenga, G., Mateus, G., and De Tomi, G. (2007). A genetic and set partitioning two-phase approach for the vehicle routing problem with time windows. Computers & Operations Research, 34(6):1561–1584. Andelmin, J. (2014). Electric vehicle routing with realistic recharging models. Master’s thesis, Aalto
University, Helsinki, Finland.
Artigues, C., Michelon, P., and Reusser, S. (2003). Insertion techniques for static and dynamic resource-constrained project scheduling. European Journal of Operational Research, 149(2):249–267.
Bartolini, E. and Andelmin, J. (2017). An exact algorithm for the green vehicle routing problem. Transpo-ration Science.
Bruglieri, M., Pezzella, F., Pisacane, O., and Suraci, S. (2015). A variable neighborhood search branching for the electric vehicle routing problem with time windows. Electronic Notes in Discrete Mathematics, 47:221–228.
Codato, G. and Fischetti, M. (2006). Combinatorial Benders’ Cuts for Mixed-Integer Linear Programming. Operations Research, 54(4):756–766.
Desaulniers, G., Errico, F., Irnich, S., and Schneider, M. (2016). Exact Algorithms for Electric Vehicle-Routing Problems with Time Windows. Operations Research, 64(6):1388–1405.
Erdo˘gan, S. and Miller-Hooks, E. (2012). A green vehicle routing problem. Transportation Research Part E: Logistics and Transportation Review, 48(1):100–114.
Felipe, A., Ortu˜no, M., Righini, G., and Tirado, G. (2014). A heuristic approach for the green vehicle routing problem with multiple technologies and partial recharges. Transportation Research Part E: Logistics and Transportation Review, 71:111 – 128.
Froger, A., Mendoza, J., Jabali, O., and Laporte, G. (2017). New formulations for the electric vehicle routing problem with nonlinear charging function. Technical report, CIRRELT-2017-30.
Gendron, B., Scutell`a, M., Garroppo, R., Nencioni, G., and Tavanti, L. (2014). A Branch-and-Benders-Cut Method for Nonlinear Power Design in Green Wireless Local Area Networks. Technical Report CIRRELT-2014-42, CIRRELT.
Grangier, P., Gendreau, M., Lehu´ed´e, F., and Rousseau, L.-M. (2017). A matheuristic based on large neigh-borhood search for the vehicle routing problem with cross-docking. Computers & Operations Research, 84:116–126.
Hiermann, G., Puchinger, J., Ropke, S., and Hartl, R. (2016). The electric fleet size and mix vehicle routing problem with time windows and recharging stations. European Journal of Operational Research, 252(3):995 –1018.
Keskin, M. and ˘Catay, B. (2016). Partial recharge strategies for the electric vehicle routing problem with time windows. Transportation Research Part C: Emerging Technologies, 65:111 – 127.
