# Abstract

Timed event graphs (TEGs) are a subclass of timed Petri nets that model synchronization and delay phenomena, but not conflict or choice. We consider a scenario where a number of TEGs share one or several resources and are subject to changes in their output-reference signals. Because of resource sharing, the resulting overall discrete event system is *not* a TEG. We propose a formal method to determine the optimal control input for such systems, where optimality is in the sense of the widely adopted just-in-time criterion. Our approach is based on a prespecified priority policy for the TEG components of the overall system. It builds on existing control theory for TEGs, which exploits the fact that, in a suitable mathematical framework (idempotent semirings such as the max-plus or the min-plus algebra), the temporal evolution of TEGs can be described by a set of linear time-invariant equations.

# Zusammenfassung

Zeitbehaftete Synchronisationsgraphen (ZSGen) bilden eine spezielle Klasse zeitbehafteteter Petri-Netze. Sie können Synchronisations- und Verzögerungsphänomene modellieren, nicht aber Konflikte. Wir untersuchen ein Szenario, in dem sich mehrere ZSGen eine oder mehrere Ressourcen teilen und die Referenzsignale der ZSGen unvorhersehbaren Änderungen unterworfen sind. Da die beteiligten ZSGen um Ressourcen konkurrieren, ist das Gesamtsystem kein ZSG. Wir beschreiben eine formale Vorgehensweise zur Bestimmung des im just-in-time Sinne optimalen Stellsignals für dieses Gesamtsystem. Unser Ansatz basiert auf einer vorab festgelegten Priorisierung der einzelnen ZSGen. Er baut auf der existierenden Regelungstheorie für ZSGen auf und nutzt die Tatsache, dass sich die zeitliche Entwicklung von ZSGen in einem geeigneten mathematischen Rahmen (idempotente Halbringe wie beispielsweise die max-plus- oder die min-plus-Algebra) durch lineare zeitinvariante Gleichungen beschreiben lässt.

## 1 Introduction

In this paper, we consider a scenario where several discrete event subsystems, each modeled by a timed event graph (TEG), share one or more resources and where the reference signals for the subsystems may change unexpectedly. TEGs are a subclass of timed Petri nets. They are characterized by the fact that each place has precisely one upstream and one downstream transition and all arcs have weight one. TEGs can model synchronization and delay phenomena but not conflict, choice, or the sharing of resources. Therefore, the overall system class investigated in this contribution is more general than the subclass of TEGs. We argue that it models a wide range of application scenarios, e. g., in manufacturing or transportation. We aim at determining the optimal control input, where optimality is understood in the sense of the widely adopted just-in-time criterion. In particular, the aim is to fire all input transitions as late as possible while guaranteeing that the firing of output transitions is not later than specified by the respective reference signal. For example, in a manufacturing context, the firing of an input transition could correspond to the provisioning of raw material, while the firing of an output transition could model the completion of a workpiece. In general, a just-in-time policy aims at satisfying customer demands while minimizing internal stocks. We solve this optimal control problem for a fixed prioritization of subsystems, but allow updates of the reference signals.

It is a well-known fact that in a suitable mathematical framework, namely an idempotent semiring (or dioid) setting such as the max-plus or the min-plus algebra, the evolution of TEGs can be described by linear equations (see [3] for a thorough coverage). Based on such linear dioid models, an elaborate control theory has become available. Given an a-priori known reference signal, it mostly focuses on optimality in the sense of the just-in-time criterion and considers feedforward and (output or state) feedback control. For a tutorial introduction to this control framework, the reader may refer to [11].

In some applications, it may be necessary to update the reference for the system’s output during run-time, for instance when customer demand is increased and a new production objective must be considered. In [12], a strategy has been presented to optimally update the input in face of such changes in the output-reference. In case the new reference encodes unachievable requirements, the authors show how to relax it such that optimal control for the relaxed reference leads to firing times of the output transitions that are as close as possible to (but possibly later than) the originally desired ones.

Systems of practical interest often involve limited resources that are shared among different subsystems. As examples, one can think of an automated manufacturing cell where the same tool/robot may be required in several steps of the production process, or of computational tasks competing for the use of a fixed number of processors. TEGs do not allow for concurrency or choice and hence are inapt to model such resource-sharing phenomena. Overcoming this limitation has motivated several efforts in the literature, with a predominant focus on modeling and analysis. In [7], [6], a modeling strategy for continuous timed Petri nets is proposed where conflict places are handled by the use of priority rules. In [8], constraints due to resource sharing are translated into additional inequalities in the system model. [1] models conflicting TEGs by max-plus time-varying equations; the models are restricted to safe conflict places. [5] relaxes the safety hypothesis on the conflict places and studies cycle time evaluation on conflicting TEGs with multiple shared resources. Works focusing on control of TEGs with resource sharing are less abundant. In [15], the authors show that concurrency can be incorporated into switching max-plus linear systems models and apply model predictive control techniques to obtain the optimal switching sequence. In [13], the modeling and control of a number of TEGs that share resources is addressed. Obviously, because of resource sharing, the overall system is no longer a TEG. Under a prespecified priority policy, the authors show how to compute the optimal (just-in-time) input for each subsystem with respect to its individual output-reference.

In this paper, we propose a formal method to obtain the optimal control inputs in face of changes in the output-references for TEGs that share resources under a given priority policy, thus merging the results from [12] with those of [13]. This paper represents an extended version of a recent conference paper [14]. It extends the contributions of [14] in the following ways: the results are presented more didactically, with more detailed explanations of some crucial steps. Most significantly, we generalize the method to the case of an arbitrary number of shared resources (Section 5.3 is entirely new), whereas in [14] only the case of a single shared resource is explicitly covered; as a prerequisite thereto, we also formalize the extension of the results from [13], originally only presented for at most two shared resources, to the case of multiple shared resources — Section 4.3 originates here. The examples in this paper, although still simple, are more general and elucidative than those from [14]. We also enhance the presentation of preliminary concepts, providing a brief survey of the theoretical background and making the paper largely self-contained.

Prospective applications for the proposed approach include emergency call centers (as studied, e. g., in [2], which, in turn, is based on [7], [6]) where the arrival of high-priority calls may render it necessary to reschedule the answers to lower-priority ones, or manufacturing scenarios where changes in the demand of high-priority products will require a re-adjustment of resource allocations by processing steps related to lower-priority products.

We consider a set of TEGs operating under optimal schedules with respect to their individual output-references and to the priority policy; supposing the output-reference of one or more of the subsystems is updated during run-time, we show how to optimally update all their inputs so that their outputs are as close as possible to the corresponding new references and the priority policy is still observed. In case the performance limitation of the subsystems, combined with the limited availability of the resources, make it impossible to respect some of the new references, we also provide the optimal way to relax such references so that the ultimately obtained inputs lead to tracking them as closely as possible.

The examples presented along this paper serve solely the purpose of illustrating and helping to clarify the results. Due to space limitations and also to the fact that existing computational tools are not in pace with the state-of-the-art theoretical results proposed here, we do not present a more comprehensive example. The proposed method can, however, be applied to larger, more general systems of practical relevance.

The paper is organized as follows. Section 2 summarizes well-known facts on idempotent semirings. In Section 3, we adapt existing results on the control of TEGs with output-reference update to the idempotent semiring used in this paper. Section 4 provides an overview of previous results on modeling and control of TEGs with shared resources. The major purpose of these three sections is making the paper as self-contained as possible. In Section 5, the main contributions of the paper are presented; namely, we formulate and solve the problem of determining the optimal control inputs for TEGs with shared resources in face of changes in the output-references. Section 6 presents the conclusions and final remarks.

## 2 Preliminaries

In this section, we present a summary of some basic definitions and results on idempotent semirings and timed event graphs; for an exhaustive discussion, the reader may refer to [3]. We also touch on some topics from residuation theory and control of TEGs (see [4] and [11], respectively).

### 2.1 Idempotent semirings

An *idempotent semiring* (or *dioid*) *sum*) and ⊗ (*product*), such that: ⊕ is associative, commutative, idempotent (i. e., *zero*) element, denoted *ε*; ⊗ is associative, distributes over ⊕, and has a neutral (*unit*) element, denoted *e*; the element *ε* is absorbing for ⊗ (i. e.,

Note that *ε* is the bottom element of

An idempotent semiring *complete* if it is closed for infinite sums and if the product distributes over infinite sums. For a complete idempotent semiring, the top element is defined as *greatest lower bound* (or *infimum*) operation, denoted ∧, by

∧ is associative, commutative, and idempotent, and we have

### Example 1.

The set *minimum* operation as ⊕ and conventional addition as ⊗, forms a complete idempotent semiring called *min-plus algebra*, denoted

### Remark 2 ([3]).

The set of

for all *e* on the diagonal and *ε* elsewhere; the zero (resp. top) element is the *ε* (resp. ⊤). The definition of order (1) implies, for any

It is possible to deal with nonsquare matrices in this context (including, in particular, row and column vectors) by suitably padding them with *ε*-rows or columns; this is done only implicitly, as it does not interfere with the relevant parts of the results of operations between matrices. ♢

A mapping *isotone* if

### Remark 3.

The composition of two isotone mappings is isotone. ♢

### Remark 4.

Let Π be an isotone mapping over a complete idempotent semiring

Algorithms exist which allow to compute the least and greatest fixed points of certain isotone mappings over complete idempotent semirings. In particular, the algorithm presented in [11] is applicable to the relevant mappings considered in this paper.

In a complete idempotent semiring

### 2.2 Semirings of formal power series

Let *δ*-*transform* of *s* is a formal power series in *δ* with coefficients in

We denote both the sequence and its *δ*-transform by the same symbol, as no ambiguity will occur. Since

multiplication by *δ* can be seen as a backward shift operation.

### Definition 6.

The set of formal power series in *δ* with coefficients in

is a complete idempotent semiring, denoted

In this paper we will use sequences to represent the number of firings of transitions in TEGs, so that each term *t*. Naturally, this interpretation carries over to the terms of a series *s* corresponding to the *δ*-transform of such a sequence. A series thus obtained is clearly nonincreasing (in the order of *t*. We will henceforth refer to such series as *counters*.

### Definition 7.

The set of counters (i. e., nonincreasing power series) in *t*, unit element *t*. We will denote this semiring by Σ, for brevity. ♢

It is easy to see that

Counters can be represented compactly by omitting terms *s* with

### 2.3 TEG models in idempotent semirings

A timed Petri net is a tuple *P* is a finite set of places (graphically represented by circles), *T* a finite set of transitions (represented by bars), *w* a weight function assigning a positive integer weight to every arc, and *h* a function assigning a nonnegative holding time to each place. In the following, holding times will be restricted to be integers. Furthermore, the function *v* assigns to each place a nonnegative integer number of tokens residing initially in this place. For any *p* is an upstream place of *t*, and *t* is a downstream transition of *p*; analogously, if *t* is said to be an upstream transition of *p*, and *p* is a downstream place of *t*. The dynamics of a timed Petri net is governed by the following rules: (i) a transition *t* can fire if all its upstream places *p* contain at least *t* fires, it removes *p* and deposits

Timed event graphs (TEGs) are timed Petri nets in which each place has exactly one upstream and one downstream transition and all arcs have weight 1. In a TEG, we can distinguish input transitions (those that are not affected by the firing of other transitions), output transitions (those that do not affect the firing of other transitions), and internal transitions (those that are neither input nor output transitions). In this paper, we will limit our discussion to SISO TEGs, i. e., TEGs with only one input and one output transition, which we denote respectively by *u* and *y*; internal transitions are denoted by

### Figure 1

A TEG is said to be operating under the *earliest firing rule* if every internal and output transition fires as soon as it is enabled.

With each transition *t*. Similarly, we associate sequences *u* and *y*, respectively. Considering the TEG from Fig. 1 operating under the earliest firing rule, in conventional algebra we have

i. e., the number of firings of transition *t* is the minimum between the number of firings of transition *u* up to time *t* and the number of firings of transition

In

which, through the *δ*-transform, can be expressed in Σ as

We can obtain similar relations for *y* and, defining the vector

In general, a TEG can be described by implicit equations over Σ of the form

From Remark 5, the least solution of (2) is given by

where *transfer function* of the system. For instance, for the system from Fig. 1 we obtain the (scalar) transfer function

### 2.4 Residuation theory

Residuation theory provides, under certain conditions, greatest (resp. least) solutions to inequalities such as

### Definition 8.

An isotone mapping *residual* of *f*.

Mapping *f* is said to be dually residuated if for all *dual residual* of *f*. ♢

Note that, if equality

### Theorem 9 ([4]).

*Mapping f as in Def.* *8**is residuated if and only if there exists a unique isotone mapping**such that*^{[1]}*and**, where**and**are the identity mappings on**and**, respectively.* ♢

### Remark 10.

For *a*”). More generally, for

### 2.5 Optimal control of TEGs

Assume that a TEG to be controlled is modeled by equations (2) and that an output-reference *u* the least possible number of times while guaranteeing that the output transition *y* fires, by each time instant, at least as many times as specified by *z*. In other words, we seek the greatest *u* (in the order of Σ) such that

### Example 12.

For the TEG from Fig. 1, suppose it is required that transition *y* fires once at time *y* should be *e* (=0) for `++` toolbox introduced in [9]. We interpret the place with holding time 3 between

## 3 Optimal control of TEGs with output-reference update

The material of this section is a dual version, adapted to the point of view of counters, of the results from [12].

In practice, it may be necessary to update the reference for the output of a system during run-time, for instance when customer demand is increased and a new production objective must be taken into account. For a system like the one from Example 12, let reference *z* be updated to a new one, *T*. The problem at hand is to find the input *T*. Define the mapping

Our objective can then be restated as follows: find the greatest element

where *z*, computed as in (4). The following theorem provides, given that certain conditions are met, a way to compute this greatest element.

## Theorem 13 ([12]).

*Let**and**be complete idempotent semirings,**residuated mappings, and**. If the set*

*is nonempty, we have*

*.*♢

### Figure 2

An obvious correspondence between

## Remark 14.

Mapping

In fact,

Hence, as long as set

In order to check for nonemptiness of

i. e., the set of counters that up to and including time *T* are identical to

Since

## Example 15.

For the system from Example 12 (Fig. 1) operating according to the optimal input obtained for output-reference *z*, suppose that at time *y* are now required at

### Figure 3

In case *z* up to time *T* may make it impossible to satisfy a more demanding new reference

is not empty. The following result provides the answer.

## Proposition 16.

*The least counter**such that**is**.*

## Proof.

Since

A correspondence between

Note that in case

## Example 17.

Consider, once more, the system from Example 12 (Fig. 1) operating according to the optimal input obtained for output-reference *z*, and suppose the same new output-reference

### Figure 4

### Figure 5

## 4 Modeling and optimal control of TEGs with resource sharing

We now turn our attention to systems in which a number of TEGs share one or multiple resources. We first focus on the simple case of a single shared resource (Sections 4.1 and 4.2); the discussion is based on [13], where the authors also present the more general case of two shared resources. Here, we take it one step further and explicitly generalize the approach to the case of arbitrarily many shared resources (Section 4.3).

### 4.1 Modeling of TEGs with one shared resource

Consider a system consisting of TEGs *β* may, in general, be a TEG (or, in simple cases, just a single place) describing the capacity of the resource as well as the minimal delay between release and allocation events. Clearly, the overall system is no longer a TEG, as there are places with several upstream and/or several downstream transitions. For simplicity, let us assume that input transitions (

It is not possible to model systems exhibiting resource-sharing phenomena by linear equations such as (2). Considering a system like the one from Fig. 5, in order to express the relationship among counters *Hadamard product* of series is introduced ([10]).

### Definition 18.

The Hadamard product of

This operation is commutative, distributes over ⊕ and ∧, has neutral element

### Figure 6

Consider a *join* structure (i. e., a place with two or more incoming transitions) as shown in Fig. 6. At any time instant *t*, the accumulated number of firings of *γ*, in conventional algebra, cannot exceed that of *fork* structure (i. e., a place with two or more outgoing transitions) such as the one shown in Fig. 6, the accumulated number of firings of *λ*, meaning

Generalizing these ideas allows us to write, for the system from Fig. 5,

which, combined with

### 4.2 Optimal control of TEGs with one shared resource

For a system like the one from Fig. 5, competition for the resource is, in general, going to make it impossible for all subsystems to concurrently follow a just-in-time schedule with respect to their individual output-references. One way to settle the dispute is introducing a priority policy among the subsystems. We henceforth assume, without loss of generality, that subsystem

### Figure 7

Let the input-output behavior of each

In fact, we want to determine the greatest

the following result comes in handy.

### Proposition 19 ([10]).

*For any**, the mapping**,**, is residuated. For any**,**, denoted**, is the greatest**such that**.* ♢

From Proposition 19, inequality (11) leads to

writing

which, in turn, implies

Since for any

The greatest

Notice that

Using the same procedure, we obtain, for each *k*,

and, defining a mapping

### Figure 8

### Figure 9

### Example 20.

Consider the system from Fig. 8, where subsystems

yields

### 4.3 Modeling and optimal control of TEGs with multiple shared resources

Consider, as before, a system comprising *K* TEGs *L* resources, as shown in Fig. 9. Similarly to Section 4.1, each *ℓ*. We denote by *ℓ* by subsystem *ℓ* by

Through the same reasoning as applied in Section 4.1, it is straightforward to conclude that, for each

The optimal (just-in-time) schedule for the usage of the resources is sought under the same priority policy as in Section 4.2. Let the input-output behavior of each

In order to determine the optimal input

Notice that, for a just-in-time input *ℓ* and, furthermore, such that a just-in-time behavior is enforced throughout the system, implying

we have

which, proceeding similarly to Section 4.2, leads to

Define, for each

We seek the greatest

The same arguments presented above can be applied to determine

and expressing each

Then, proceeding as before and defining the mapping

for each

### 4.4 Supplementary remarks

### Proposition 21 (Adapted from [10]).

*Let**. For any**, the mapping**,**, is dually residuated. For any**,**, denoted**, is the least**such that**.*

### Proof.

For an arbitrary

### Remark 22 ([10]).

Given two counters *s* (in the order of *s*. ♢

Note that, in Proposition 21, the restriction of *a* to the subset

### Remark 23.

Since we take a term like *η* firings by time *τ*, it is reasonable to assume that the counters *u*, *y* (cf. Section 2.3) are elements of

## 5 Optimal control of TEGs with resource sharing and output-reference update

In this section, as the main contribution of this paper, we incorporate the ideas discussed in Section 3 to the class of systems studied in Section 4 by showing how to determine the optimal (just-in-time) control inputs in face of changes in the output-references for TEGs that share resources under a given priority policy. We again emphasize that, in this setting, the overall system is not a TEG.

This section is structured similarly to Section 4, starting with the simple case of a single shared resource (Sections 5.1 and 5.2) and then generalizing to the case of multiple resources (Section 5.3).

### 5.1 Problem formulation: the case of a single shared resource

Consider the system from Fig. 5 and assume every subsystem *T* each *k*, the input *T*. The crucial difference is that now the priority scheme must be observed and, furthermore, the past resource allocations by subsystems with lower priority must also be respected. Such allocations are relevant — despite having occurred before time *T* — because the respective resource releases may take place after *T*, thus influencing the availability of the resource in the meantime.

For the purpose of the discussion to follow, let us fix an arbitrary *t*. Respecting the past means that the firings which have already occurred by time *T* (when the new references are received) cannot be revoked. On the other hand, the prospective firings that have not taken place by time *T* can still be postponed and hence, from the point of view of

In sum, (i) we must compute

It will be convenient to define the following terms:

*T*) of resource-allocation transitions

*T*, whereas

*T*, the respective resource-release events may take place after

*T*, so in general one may have

Thus, based on (9) and on the foregoing discussion, in order to update

where it is understood that for

The problem of determining the new optimal input *T* can be formulated as follows: find the greatest element of the set

### Remark 24.

It should be clear that, for any

### 5.2 Optimal update of the inputs: the case of a single shared resource

We set out to look for the greatest element of set

### Proposition 25.

*Let**and**be complete idempotent semirings,**residuated mappings,**, and**. Consider the set*

*and the isotone mapping*

*,*

*If*

*, we have*

*.*

### Proof.

Define the set

and denote

So, we can rewrite

Now, assume

Now, let us once more fix an arbitrary

by defining the mapping

we can write

This reveals a correspondence between set *ψ* as *c* as

Next, we must investigate when

we want to show that

i. e., that there exists a (unique) least counter, which we will denote by

Note that, from Proposition 21 and Remark 23, the mapping

one can see that

(which, according to Remark 4, is the least fixed point of

To prove the converse inequality, we proceed to show that

### Proposition 26.

*.*

### Proof.

Any

and, by consequence (cf. Def. 8), also satisfies (⋆). According to Remark 4,

Moreover,

But note that

so (24) is equivalent to

which, in turn, implies

This, together with the fact that

A direct consequence of Proposition 26 is that

thus proving that (22) holds. Isotony of

In case

is nonempty. The solution is given by the following result.

### Proposition 27.

*The least counter**such that**is**.*

### Proof.

Taking

Following the same reasoning as before, we define the mapping

with *ψ* as

### Example 28.

Consider the system from Example 20 (Fig. 8), with

We now proceed to update

Finally, for

The updated optimal schedules are shown in Fig. 10. ♢

### 5.3 Extension to the case of multiple shared resources

Consider the system from Fig. 9, with every subsystem *T* (with perhaps *k*, the optimal input *T* and results in the output

### Figure 10

As usual, we base the following discussion on a fixed but arbitrary

Still along the lines of Section 5.1, define the terms

which can be explained as in the referred section, only now for each resource *ℓ*. We aim at updating

where it is understood that for

We can then formulate the problem of optimally updating the input *T* as follows: find the greatest element of the set

Recall from Section 4.3 that we can write

which is equivalent to

Define the mappings

We can then rewrite

Note that *ψ* as *c* as

In order to check whether

We want to show that

i. e., that there exists a (unique) least counter

and also the mapping

Since (⋆⋆) is equivalent to (28) which, in turn, is equivalent to

one can see that for any element *ℓ*. As

we have

By arguments parallel to those put forth in Section 5.2, it can be shown that the converse inequality also holds, so we have

Analogously to (26), this leads to the conclusion that

In case

is nonempty. A straightforward adaptation of Proposition 27 gives the solution

Following the same reasoning as before, we define the mapping

with *ψ* as

## 6 Conclusion

This paper solves the problem of ensuring that a number of TEGs competing for the use of shared resources operate optimally (in a just-in-time sense) even in face of changes in their output-references. The proposed method assumes a prespecified priority policy on the component TEGs, and the optimal inputs are computed under the rule that the operation of lower-priority subsystems cannot interfere with the performance of higher-priority ones. However, when higher-priority subsystems recompute their inputs after a change in the reference signal occurs, they need of course to respect past resource allocations by lower-priority subsystems. We also study the case in which the limited availability of the resources renders it impossible to respect the updated output-reference for one or more of the subsystems. In this case, we show how to relax such references in an optimal way so that the ultimately obtained inputs lead to tracking them as closely as possible. The results are illustrated through simple examples. Exploiting the generality of the method and applying it to a larger, more realistic case study is a subject for future work.

This contribution is dedicated to Prof. Dr.-Ing. Dr. h.c. Michael Zeitz on the occasion of his 80th birthday.

**Funding source: **Deutsche Forschungsgemeinschaft

**Award Identifier / Grant number: **RA 516/14-1

**Funding statement: **Financial support from Deutsche Forschungsgemeinschaft (DFG) via grant RA 516/14-1 is gratefully acknowledged.

### References

1. B. Addad, S. Amari and J.-J. Lesage. Networked conflicting timed event graphs representation in (max,+) algebra. *Discrete Event Dynamic Systems*, 22(4):429–449, 2012.10.1007/s10626-012-0136-0Search in Google Scholar

2. X. Allamigeon, V. Bœuf and S. Gaubert. Performance evaluation of an emergency call center: tropical polynomial systems applied to timed petri nets. In *Formal Modeling and Analysis of Timed Systems (FORMATS 2015)*, Springer, 2015.10.1007/978-3-319-22975-1_2Search in Google Scholar

3. F. Baccelli, G. Cohen, G. J. Olsder and J.-P. Quadrat. *Synchronization and Linearity: an Algebra for Discrete Event Systems*. Wiley, 1992.Search in Google Scholar

4. T. Blyth and M. Janowitz. *Residuation Theory*. Pergamon press, 1972.Search in Google Scholar

5. W. M. Boussahel, S. Amari and R. Kara. Analytic evaluation of the cycle time on networked conflicting timed event graphs in the (max,+) algebra. *Discrete Event Dynamic Systems*, 26(4):561–581, 2016.10.1007/s10626-015-0220-3Search in Google Scholar

6. G. Cohen, S. Gaubert and J. P. Quadrat. Asymptotic throughput of continuous timed petri nets. In *34th IEEE Conference on Decision and Control (CDC)*, New Orleans, LA, USA, 1995.Search in Google Scholar

7. G. Cohen, S. Gaubert and J. P. Quadrat. Algebraic system analysis of timed petri nets. In *Idempotency*, J. Gunawardena Ed. Collection of the Isaac Newton Institute, pages 145–170, 1998.10.1017/CBO9780511662508.010Search in Google Scholar

8. A Corréïa, A. Abbas-Turki, R. Bouyekhf and A. El Moudni. A dioid model for invariant resource sharing problems. *IEEE Transactions on Systems, Man, and Cybernetics*, 39(4):770–781, 2009.10.1109/TSMCA.2009.2019867Search in Google Scholar

9. B. Cottenceau, L. Hardouin and J. Trunk. A C++ toolbox to handle series for event-variant/time-variant (max,+) systems. In *15th International Workshop on Discrete Event Systems (WODES’20) — to appear*.Search in Google Scholar

10. L. Hardouin, B. Cottenceau, S. Lagrange and E. Le Corronc. Performance analysis of linear systems over semiring with additive inputs. In *9th International Workshop on Discrete Event Systems (WODES)*, Göteborg, Sweden, 2008.10.1109/WODES.2008.4605920Search in Google Scholar

11. L. Hardouin, B. Cottenceau, Y. Shang and J. Raisch. Control and state estimation for max-plus linear systems. *Foundations and Trends in Systems and Control*, 6(1):1–116, 2018.10.1561/9781680835458Search in Google Scholar

12. E. Menguy, J.-L. Boimond, L. Hardouin and J.-L. Ferrier. Just-in-time control of timed event graphs: update of reference input, presence of uncontrollable input. *IEEE Transactions on Automatic Control*, 45(11):2155–2159, 2000.10.1109/9.887652Search in Google Scholar

13. S. Moradi, L. Hardouin and J. Raisch. Optimal control of a class of timed discrete event systems with shared resources, an approach based on the hadamard product of series in dioids. In *56th IEEE Conference on Decision and Control (CDC)*, Melbourne, Australia, 2017.10.1109/CDC.2017.8264373Search in Google Scholar

14. G. Schafaschek, S. Moradi, L. Hardouin and J. Raisch. Optimal control of timed event graphs with resource sharing and output-reference update. In *15th International Workshop on Discrete Event Systems (WODES’20) — to appear*.Search in Google Scholar

15. T. J. J. van den Boom and B. De Schutter. Modelling and control of discrete event systems using switching max-plus-linear systems. *Control Engineering Practice*, 14(10):1199–1211, 2006.10.1016/j.conengprac.2006.02.006Search in Google Scholar

**Received:**2020-04-08

**Accepted:**2020-06-04

**Published Online:**2020-07-03

**Published in Print:**2020-07-26

© 2020 Schafaschek et al., published by De Gruyter

This work is licensed under the Creative Commons Attribution 4.0 Public License.