Using Publish/Subscribe Middleware for Distributed ...

Using Publish/Subscribe Middleware for Distributed EV Charging Optimization Jose Rivera, Martin Jergler, Aleksandar Stoimenov, Christoph Goebel, Hans-Arno Jacobsen Dept. of Comuter Science Technische Universit¨at M¨unchen (TUM) Munich, Germany {riveraac, jergler, stoimeno, goebelc, jacobsen}@in.tum.de Abstract—This paper explores advantages that a publish/subscribe middleware can offer for the implementation of an efficient and reliable electric vehicle (EV) charging control infrastructure. We propose DOPS, a framework for distributed optimization of EV charging, that works on top of a pub/sub middleware and extends it to support in-network aggregation. For our evaluation, we deployed DOPS in a testbed consisting of 15 virtual machines connected via a VLAN network and compared three different communication schemes: centralized, decentralized and decentralized with aggregation. Our results show that for 120 EVs a centralized approach is faster. However, the trend shows that for more than 150 EVs decentralized approaches will offer better performance. Moreover, we show that the aggregation feature of DOPS doubles the performance of a decentralized approach. Our results thus demonstrate that distributed control infrastructures can benefit from using pub/sub middleware. Keywords—Distributed computing, Publish-subscribe, Electric vehicles, Optimization

I.

I NTRODUCTION

Motivation – Many governments around the world have identified Electric Vehicles (EVs) as a valuable resource to (1) reduce CO2 emissions [4] and (2) help with the integration of renewable energy. For instance, the German government has set the goal of 1 million EVs until 2020 [1]. Once available in large numbers, EVs could provide substantial, reliable system services with limited end-use disruption [3]. Two main characteristics make EVs a promising resource for providing grid services. EVs, or cars in general, are parked most of their lifetime and their energy needs can be predicted. However, to profit from the flexibility of EVs, an intelligent control infrastructure must consider the following aspects: To have a significant influence on the power grid it is necessary to control the behavior of large numbers of EVs, which calls for a scalable system. Moreover, EVs will be geographically dispersed and consequently their charging control calls for a distributed communication and coordination infrastructure. Lastly, the owners of EVs must accept remote charging control, meaning that they have to rely on the control to fulfill their energy requirements, preferably without having to expose private information like their driving behavior (i.e., privacy). In this paper, we consider that a distributed control system supported by a publish/subscribe middleware can be a good approach to address these requirements. Problem statement – The task of scheduling EV charging jobs can be expressed as an optimization problem. The grid operator’s goal may vary depending on its needs. Example

goals are the balancing of demand and supply, the flattening of the demand profile, also known as valley filling, or the use of EVs to store renewable energy. Most of these goals relay on prediction techniques to estimate supply and demand for a certain future horizon to enable a planning of the grid operations. For this task, we also have to consider that EVs want to reach a certain level of charge at a specific point in time. This point in time can be determined by taking the driving profiles of individual EVs into account (i.e., a predictive estimation of their behavior [8]). This allows the definition of a period of time, in which the EV’s charging job can be flexibly scheduled. Based on this, the grid operator, which assumes the role of EV aggregator, takes the EVs’ energy requirements into account and performs an optimization procedure to maximize its value function. To implement this control approach, an information and communication system between the EVs and the aggregator is required. In this work, we focus on the design of this system. We propose the DOPS middleware, which is based on the publish and subscribe messaging pattern to support the implementation of some of the latest EV charging algorithms available in the literature. Related Work – In recent years, several algorithms and strategies for EV charging control have been proposed. In [3], the centralized control of flexible loads is discussed and the need for scalable and distributed control algorithms for EV charging is stated. A centralized EV charging optimization algorithm is discussed in [2] and subsequently implemented using a centralized communication system for the island of Bornholm, Denmark. The problem of scalability was addressed with the design of distributed optimization algorithms in [7] for the valley filling problem and later generalized in [13]. This resulted in the design of distributed EV charging control protocols. However, the majority of these studies are focusing on the correctness and the effectiveness of the proposed algorithms. So far there is only very limited work proposing and evaluating a concrete architecture for the realization and deployment of such approaches. For example, in [9] the scheduling of various energy devices was solved using distributed optimization and implemented over a message passing interface. Nevertheless, there has not been a comprehensive comparison between the centralized and the decentralized EV charging control approaches. This is not a trivial issue, since decentralized approaches solve the problem of scalability, but they also significantly increase the number of messages that need to be exchange between the EVs and the aggregator (cf., [13]). In this paper, we propose a distributed system architecture for EV charging control and compare centralized with decentralized

600

Overview of approach – We propose a holistic system architecture for EV charging control and an implementation that is based on a distributed publish/subscribe (pub/sub) infrastructure. On top of our pub/sub communication model lies DOPS (cf., Fig. 3), an agent-based optimization framework enabling the implementation of various EV charging protocols like [7], [13]. In this settings, aggregator and EVs are considered as agents that implement their own logic in order to calculate the global optimization result. Our literature review of EV charging control algorithms revealed a set of common characteristics all of them share. This is, for instance, an iterative computational model (i.e., approximation to the final charge schedule for each EV), local optimizations at individual devices (EVs), and the aggregation of results (e.g., Sum or Average) over data that is exchanged between the aggregator and EVs during the execution of such algorithms. Using DOPS, we implemented three execution strategies for a state-of-the-art protocol [7]: A centralized baseline implementation, where all EVs send their relevant data to the aggregator, who then performs the optimization. A decentralized optimization strategy where EVs and the grid operator exchange information iteratively over a standard pub/sub infrastructure, and the same decentralized strategy leveraging the in-network aggregation capabilities of DOPS. Contributions – (I) We propose DOPS, a pub/sub middleware framework for distributed optimization that provides a concise interface to compare different EV charging protocol implementations in a distributed environment. (II) We expand the decentralized algorithms for EV charging, by providing an analytic procedure to solve the local EV optimization problems, which allows their implementation without resorting to third party optimization libraries. (III) We contribute a comprehensive benchmark of three different implementation approaches for EV charging control: centralized, decentralized, and decentralized with aggregation. We provide an extensive experimental study based on a publicly available dataset [14] showing the applicability and scalability of our proposed system architecture under real-world assumptions. Structure – The remainder of this paper is structured as follows. In Section II, we present short overview on pub/sub middleware and discuss the EV charging protocol to solve the valley filling problem. Possible implementation models for the EV charging protocol are discussed in Section III. The optimization framework DOPS is presented in Section IV and an extensive experimental study is presented in Section V before we conclude with some future research directions in Section VI. II.

BACKGROUND

A. Pub/sub middleware Publish/subscribe middleware is based on a communication paradigm, where subscribing entities register their interest in an event, or a pattern of events, and are subsequently asynchronously notified of events that are issued by publishing entities [5]. The main advantage of this paradigm is that it allows for full decoupling of the communicating participants in space and individual control flow. This offers a lot flexibility for the development of distributed applications. In this paper,

Ddemand [MW]

approaches.

500 400

Fixed demand

300 200

Total demand 4:00

8:00

12:00 16:00 Time of day

20:00

24:00

Fig. 1. Base demand profile D and flattened profile after valley-filling. Both for a one day horizon (adopted from [13]).

we exploit these advantages for the development of a platform to support distributed optimization for EV charging. In (distributed) pub/sub, events or publications are matched against a set of filters or subscriptions, respectively, in order to route the information over a (distributed) broker architecture from a source to all interested sinks [6], [10]. However, in terms of distributed optimization the main requirement, i.e., the computation of aggregates within each iteration of the algorithm, is not addressed by the standard pub/sub model. A first approach to overcome this limitation and make pub/sub a viable platform for data-intense stream processing by introducing aggregation was proposed in [12]. We designed and implemented a similar approach to reduce the number of notifications that are exchanged in the broker overlay. Apart from reducing the number of messages sent over the communication network, the ability of this approach to decouple the aggregator and the individual EVs facilitates data anonymization, as the infrastructure only provides aggregated information. Furthermore, the distributed nature of the broker architecture enables the system to scale well with the number of EVs.

B. Valley filling Without loss of generality we consider a concrete EV charging control problem: the valley filling problem [3], [7], [11], [13]. The objective in valley filling is to flatten the system’s demand profile, i.e., the base demand from the uncontrollable loads plus the flexible demand from EVs. The desired result can be seen in Fig.1. In valley-filling, the grid operator, also known as aggregator, is assumed to know the base demand profile D (i.e., the non-EV demand) of its administrative domain for a certain time horizon, e.g., by prediction. Typically, this horizon consists of a set T of T = {t1 , ..., tm } time intervals, each of length ∆T . Accordingly, D(t) denotes the base profile for time slot t. The aggregator interacts with a set N comprised of N = {EV1 , ..., EVn } EVs and defines their individual charging profiles, i.e., one column ri in the vector {r1 , ..., rn }. Each EV can charge with a maximal rate of r¯n once it is plugged in a charging station. For simplicity, we do not consider discharge, therefore the minimal charging rate of the EVs is 0. In addition, each EV must reach a certain level of charge (the required energy R) by a certain deadline (required energy constraint). To this end, each EV is aware of an estimate of (1) when it will be plugged in or not and (2) how much energy it requires by the deadline. We call this information driving profile of EVi . Using this information, the valley filling

problem can be defined as:

Algorithm 2: Valley-filling at EV input : R, r0

minimize r1 ,...,rn

subject to

PT

t=1



2 PN D(t) + n=1 rn (t)

0 ≤ r (t) ≤ r¯n , t ∈ T , n ∈ N PT n n∈N t=1 rn (t) = Rn ,

1

(1)

The valley filling problem can be solved in a centralized manner with a centralized optimization. However, this is not consider to be a scalable solution and to overcome this drawback, many decentralized approaches based on distributed optimization have been proposed [3], [7], [11], [13]. C. EV charging protocol

2 3 4 5 6 7 8 9 10 11

In this work, we consider an incentive-based optimization technique that was proposed in [7]. In each iteration, the aggregator broadcasts a price signal p (i.e., the incentive signal) to all EVs. Upon reception of p, each EV calculates a new charging schedule respecting its own constraints and returns the result back to the aggregator. Based on the aggregation of intermediary charging schedules from all EVs, the operator then calculates an updated incentive signal and a new iteration is started. The algorithm terminates when the calculated error is below a certain threshold. Algorithm 1 describes the procedure at the aggregator side. The new incentive signal is the sum of the original base demand profile and the aggregation (i.e., summation) of all EV charging schedules from the last iteration. The procedure at the EV side is described in Algorithm 2 where γ is a tuning parameter depending on the number of EVs in the system. Each EV first calculates an ideal schedule without considering any constraint and then projects this ideal schedule on a feasible schedule satisfying (1) the charging bound and (2) the required energy constraints. Using DOPS, both procedures can be implemented almost exactly like depicted in Algorithms 1 and 2. Distribution remains completely transparent. We implemented the algorithm first presented in [7] without inclusion of any external software, which significantly reduced computational overhead. Algorithm 1: Valley-filling at aggregator input : D = p0 1 2 3 4 5 6 7

stopped = false; broadcast(p0 ) to all EVs; while kpk+1 − pk k2 >  do PN . Update pk+1 (t) = D(t) + n=1 rnk+1 (t); incentive broadcast(pk+1 ) to all EVs; broadcast(stopped = true); return pk+1 ; . flattened profile

III.

EV CHARGING PROTOCOL IMPLEMENTATION

We developed three different strategies to implement the valley filling algorithm explained in the following: Centralized – An intuitive way to solve valley filling is centralized optimization. The aggregator queries the driving profiles from all EVs and calculates the charging schedules on its own. However, this approach has two major drawbacks.

12 13 14

stopped = false; r0 (t) = 0 . initialization while !stopped do onReceive(pk ) . Updated incentive sumPrice = 0; for pk (ti ) ∈ pk do sumPrice+ = pk (ti ) avgPrice = sumPrice ; |pk | for rk (ti ) ∈ rk do ; factor = avgPrice pk i k+1 k r (i) = r (i) + log10 factor · 2γ · pk (ti ); PT while t=1 rk (t) − R >  do project rk+1 on R; . required energy constraint project rk+1 on 0 ≤ rk (t) ≤ ¯r; . charging bounds

The first problem is the collection of all driving profiles from large numbers of EVs. Assuming a standard centralized communication model, the implementation of a scalable and reliable system becomes challenging, specially if there are realtime requirements to implement a model predicative style of control (cf., [13]). The second problem is not of technical nature, but nevertheless highly relevant in practice: As driving profiles need to be exchanged in this approach, the aggregator eventually knows about the behavior of individual EVs and consequently the behavior of their owners. This resembles the concept of a direct control method, which may lack broad acceptance by society [3]. As a result, a centralized system may not be a practicable solution to the problem. Instead, it appears to be more promising to distribute the computation and avoid a clustering of sensitive data. Decentralized – A second approach is to leverage the decentralized nature of the algorithm and distribute the computation between aggregator and EVs. As described in Algorithm 1, the aggregator broadcasts the control signal and waits for the charging schedules, which have been calculated by each individual EV according to Algorithm 2. Both parties communicate iteratively until the total demand profile is flattened to the maximal possible extent and all final schedules are calculated. The advantage of this procedure compared to the centralized approach is that there is no need for exchanging any information about individual driving profiles. However, the problem remaining here is again the massive communication overhead, i.e., the number of messages that have to be received by the aggregator. Even worse than in the centralized setting, due to the iterative procedure of the algorithm, the agrgegator has to handle the message overhead in each iteration and not only once. Hence, due to the massive communication cost this also seems to be no ideal solution. Decentralized with aggregation – Our third approach takes advantage of an interesting characteristic in the decentralized valley filling approach. In Algorithm 1, to update the incentive signal, the aggregator needs the sum of intermediary schedules from all EVs. Actually, this calculation is the most expensive computation for the aggregator. If the aggregation

Aggregator

Pub/Sub

EV(1

.(.(.

EV(N

User-defined/Optimization/Strategy DOPS/Framework

Initialize (k=0) loop

Extended/Publish/Subscribe/Middleware

incentive(signal p

k

optimize

r1 k+1

optimize

Aggregator

optimize

rNk+1

EV1

...

EV2

EVN

schedule(1 schedule(n

aggregated(schedules

Internet

aggregate

update(incentive( k+1 signal p

Fig. 3.

Conceptual overview of DOPS.

check( convergence k(=(k+1

P/S Client

Fig. 2.

Iterative decentralized optimization. Aggregator Client

was computed on the way from EVs to the aggregator, not only the computation overhead would decrease, but also the number of messages that need to be handled would diminish from a large amount to a single one containing already the necessary aggregated value. Furthermore, with this approach the possibility to infer any sensitive information is reduced. The crucial requirement for this approach lies in a communication infrastructure that can provide aggregation as a central feature. IV.

IAggregator

A. DOPS Agents & Interface The DOPS framework provides two distinct agent types that allow for modeling different decentralized optimization approaches (cf., Figure 4). Agents extend the pub/sub client for further functionality and essentially realize the iterative communication model that is depicted in Figure 2. The aggregator agent acts as the authority to calculate and notify the incentive signal to the middleware (e.g., the grid operator in EV charging) and the Controllable Device agent (device for short) acts as an entity that optimizes based on the incentive signal and also reports its local result to the middleware. The

IControllableDev

+initialize() +getInitialIncentive() +getValue()

+initialize() +update() +getValue()

Agent

Aggregator

DOPS

In this section we describe DOPS, an agent-based framework for the execution of distributed optimization algorithms that follow an iterative computational model as depicted in Figure 2. An agent in this context represents a certain role within the optimization process that has possibly thousands of instances (e.g., an EV). DOPS is implemented in JAVA and layered on top of the distributed content-based pub/sub middleware Padres [6], which abstracts from the communication between agents and other infrastructure capabilities (cf., Figure 3). To reduce the message overhead in terms of number of messages being propagated and the overall communication delay, we developed an approach for in-network aggregation and added the corresponding feature to Padres. Aggregates are calculated over a synchronization context that resembles one iteration within the optimization process and can be any (self-) decomposable aggregation function [12] defined over application-specific data from all agents.

Controllable DeviceClient

ControllableDevice

IOptimizationStrategy +deviceOptimization() +aggregatorOptimization() +updateIncentiveSignal() +checkConvergence()

Fig. 4.

Relation of DOPS agents and P/S clients.

actual optimization procedure is encapsulated in a concrete optimization strategy that implements the IOptimization Strategy interface. This interface defines the complete optimization algorithm by specifying agent-specific code and a convergence criteria (cf., Algorithms 1 and 2). In the following, we specify the functionality of these three interfaces. Altogether they represent everything an application developer has to implement to run own optimization algorithms on a distributed infrastructure. 1)

Aggregator Interface: Consists of three method stubs. These methods do not specify any optimization logic but are crucial for executing the optimization along an iterative workflow. The application developer has to specify the return values of these methods. For instance, the initialize() method loads the required data and getInitialIncentive returns the incentive. Some functionalities are already implemented, e.g., the invocation of the optimization methods from IOptimizationStrategy. A developer has to implement the methods of the interface IAggregator in a custom Aggregator class and the Aggregator parent class will

EV_1_1

EV_1_N

Aggregator

………………………………..

3)

EV_8_1

...

do the rest. Controllable Device Interface: Interface for devices similar to the aggregator interface providing three method stubs. Again, the main purpose is to guarantee a well-defined optimization workflow. Optimization Strategy Interface: The actual optimization logic for both agent roles is specified in an implementation of the interface IOptimizationStrategy. This enables an application developer to specify the complete algorithm within a single Java class. Furthermore, it enhances flexibility as an optimization strategy can be exchanged during runtime without changing the agents.

...

2)

EV_8_N

V.

E XPERIMENTAL E VALUATION

We evaluated our framework experimentally on a test cluster comprised of 15 virtual machines running Ubuntu 12.04.4 LTS (GNU/Linux 3.2.0-58-generic x86 64). Each machine was equipped with two vCPUs @ 2.6 GHz and 512 MB RAM. All machines were part of a VLAN and we did neither constrain latency nor bandwidth. To run DOPS we used Java version 1.7.0 51 and the Open JDK Runtime Environment IcedTea v2.4.4. The general system configuration (i.e., overlay structure) we used is depicted in Figure 5. Circles in the figure denote pub/sub messaging and aggregation brokers. The brokers form a balanced tree structure. The boxes denote the pub/sub clients (i.e., the agents in DOPS). The EVs (controllable device agents) are connected to edge brokers (i.e., the leafs in the broker tree) while the grid operator (aggregator agents) is connected to the root. In this setting, the aggregator was running on the same machine as the root broker. Similar, EVs were running on the same machines as the edge brokers. We implemented the three different strategies described in Section II to solve the valley filling problem for EV fleets of variable size. We considered a one day horizon (i.e., 24 hours) and a time interval ∆T = 15 minutes. The base demand profile D was scaled based on the number of EVs to gurantee that valley filling is achievable. The data set we used is publicly available and comprised of the base demand profile for the grid operator [14] and driving profiles as well as energy demand of EVs obtained using the methods described in [8]. Experiment 1 – Comparison of approaches: In the first experiment we compared the runtime performance of the centralized approach with both decentralized approaches (i.e., with and without in-network aggregation). We used the total number of controllable devices as control parameter and ran the optimization with 8, 24, 48, 72, 96, and 120 EVs. In this setting, EVs were distributed equally among edge brokers. For instance, for overall 24 EVs there were 3 EVs connected to a single edge broker (cf., Figure 5). We took five measurements for each configuration and calculated the average of computation times. The results are depicted in Fig. 6 showing the average runtime and its deviation. The centralized approach performed best (about 2s for 72 EVs). The decentralized approach with aggregation (about 12s) outperformed no-aggregation (about 28s). The reason for the centralized approach performing so well is that there is only a single round of communication necessary between aggregator and EVs. As

Fig. 5. Experimental setup – circles are brokers withing the pub/sub overlay, boxes are DOPS agents. The dashed lines indicate different brokers to which the aggregator is connected to during experiments.

opposed to the centralized approach, the distributed approaches communicate in an iterative manner. For instance, for 72 EVs the algorithm performs 27 iterations. However, the drawback with the centralized approach is that (1) privacy of the data is not considered at all and (2) the aggregator has to handle a number of messages that is equal to the number of EVs. As this number increases, it becomes a bottleneck for the entire system, which the results for 120 EVs already indicate. Unfortunately, because of our limited computing resources, we were not able to further increase the number of EVs. Nevertheless, a power curve fitting of our measurements shown in Fig. 6 reveals that for 150 EVs the decentralized approaches will outperform the centralized approach. We can also see that the decentralized approach without aggregation suffers from the same bottleneck as the centralized approach. Again, the major drawback is that the number of messages an aggregator receives per iteration is equal to the number of EVs. By exploiting the aggregation capabilities of DOPS, this number can be reduced to only one message per iteration and performance is nearly doubled. Analyzing the trend on runtime behavior, we believe that there is a point close to the 120 EVs, at which the aggregation approach outperforms the centralized approach, i.e., according to our approximation around 140 EVs. Experiment 2 – Random distribution of EVs: In the second experiment, we compared the runtime behavior for the decentralized approach with aggregation between an equal distribution of EVs among edge brokers and an unequal distribution. Therefore, the total number of EVs was randomly distributed for each run of the optimization. The results of this experiment are depicted in Figure 7. For up to 48 EVs in total, the difference in runtime between equal (7.7 seconds) and random distribution (8 seconds), remains comparable. For 72 EVs, and more the equal distribution performs better (e.g., for 120 EVs runtime is halved). This behavior can be explained by the increased load that occurs at some of the edge brokers due to the higher amount of EVs they have to handle. Interpretation – In conclusion, we can say that with our aggregation approach for pub/sub, the distributed optimization performance is significantly improved. In our experiments, the runtime was halved. Analytically, the number of messages that

Centralized

Measurement error

70

140

60

120

50

100 Runtime(s)

Runtime(s)

Decentralized with aggregation

40 30

Approximation

80 60

20

40

10

20

0

Decentralized

publicly available data and executed on an overlay tree, shows that in-network aggregation outperforms a pub/sub system without aggregation capabilities. Although, the centralized approach still performed best for 120 EVs in terms of runtime, we predict that already for 150 EVs the decentralized approach will be faster. Due to our limited computing resources, we could not reach these scales. Nevertheless, the centralized approach does not preserve data privacy, making it difficult to use in practice. For future work, we like to extend our experiments to larger scales, incorporate a generalization to acyclic overlay topologies, and investigate the implementation of asyncrhonous distributed optimization algorithms. R EFERENCES

8 24 48 72 96 120 Total Number of EVs

8 24 48 72 96 120 150 Total Number of EVs

[1] [2]

RuntimeD(s)

Fig. 6. Experiment 1 – Runtime comparison: Centralized vs. no aggregation vs. in-network aggregation. 100 90 80 70 60 50 40 30 20 10

[3]

EqualDDistribution UnequalDDistribution

[4] [5]

[6]

8

24

48

72

96

120

[7]

TotalDnumberDofDEVs

[8] Fig. 7. Experiment 2 – Runtime comparison (aggregation) between equal and unequal (i.e., random) distribution of EVs among edge brokers. [9]

arrive at the aggregator client is reduced to a single one per iteration. This is an important fact when scaling optimization further up and considering up to large numbers of EVs. Unfortunately, due to the resources constraints in our test bed, especially the limited memory of 512 Mb per machine, we were not able to extend our experiments to larger EV fleet sizes. However, using extrapolation we can predict that for 150 EVs the decentralized approaches will gain the upper hand. We believe that the number of messages to handle at the aggregator eventually becomes the bottleneck. We plan to verify this statement in our future work. VI.

[10]

[11]

[12]

[13]

C ONCLUSION

We designed and implemented DOPS, a general purpose framework for distributed computation of incentive-based optimization algorithms over a pub/sub middleware. An application developer only needs to implement the concise interface of DOPS to specify the optimization procedures of agents to execute optimization algorithms in a distributed infrstructure. To show the applicability of our framework, we developed three alternative solutions for solving the valley-filling problem in the context of EV charging control and implemented them over DOPS. Our experimental evaluation, which was based on

[14]

German Federal Government’s National Electromobility Development Plan, 2009. C. Binding, D. Gantenbein, B. Jansen, O. Sundstrom, P. Andersen, F. Marra, B. Poulsen, and C. Traeholt. Electric Vehicle Fleet Integration in the danish EDISON Project - A Virtual Power Plant on the Island of Bornholm. In Power and Energy Society General Meeting, 2010 IEEE, pages 1–8, july 2010. D. Callaway and I. Hiskens. Achieving Controllability of Electric Loads. Proceedings of the IEEE, 99(1):184–199, jan. 2011. M. Duvall, E. Knipping, M. Alexander, et al. Environmental Assessment of Plug-in Hybrid Electric Vehicles. Technical report, 2007. P. T. Eugster, P. A. Felber, R. Guerraoui, and A.-M. Kermarrec. The Many Faces of Publish/Subscribe. ACM Comput. Surv., 35(2):114–131, June 2003. E. Fidler, H. A. Jacobsen, G. Li, and S. Mankovski. The padres distributed publish/subscribe system. In In 8th International Conference on Feature Interactions in Telecommunications and Software Systems, pages 12–30, 2005. L. Gan, U. Topcu, and S. Low. Optimal decentralized protocol for electric vehicle charging. IEEE Transactions on Power Systems, 28(2):940–951, 2013. C. Goebel and M. Voß. Forecasting Driving Behavior to Enable Efficient Grid Integration of Plug-in Electric Vehicles. IEEE Online Conference on Green Communications, 2012. M. Kraning, E. Chu, J. Lavaei, and S. Boyd. Dynamic Network Energy Management via Proximal Message Passing. Foundations and Trends in Optimization, 1(2), 2014. G. Li and H.-A. Jacobsen. Composite Subscriptions in Content-based Publish/Subscribe Systems. In Proceedings of the ACM/IFIP/USENIX 2005 International Conference on Middleware, Middleware ’05, pages 249–269, New York, NY, USA, 2005. Springer-Verlag New York, Inc. Z. Ma, D. Callaway, and I. Hiskens. Decentralized charging control for large populations of plug-in electric vehicles: Application of the Nash certainty equivalence principle. In Control Applications (CCA), 2010 IEEE International Conference on, pages 191–195, sept. 2010. N. K. Pandey, K. Zhang, S. Weiss, R. Vitenberg, and H.-A. Jacobsen. Distributed Event Aggregation for Content-based Publish/Subscribe Systems. In Distributed Event-based Systems (DEBS), 2014. J. Rivera, P. Wolfrum, S. Hirche, C. C. Goebel, and H.-A. Jacobsen. Alternating Direction Method of Multipliers for Decentralized Electric Vehicle Charging Control. In 52nd IEEE Conference on Decision and Control (CDC), page 6, 2013. SWM M¨unchen. Netzdaten. http://www.swminfrastruktur.de/strom/netzstrukturdaten/netzdaten.html. Accessed: 2012-11-16.