Performance Optimization for a Class of Petri Nets

Abstract

Petri nets (PNs) are widely used to model flexible manufacturing systems (FMSs). This paper deals with the performance optimization of FMSs modeled by Petri nets that aim to maximize the system’s performance under a given budget by optimizing both quantities and types of resources, such as sensors and devices. Such an optimization problem is challenging since it is nonlinear; hence, a globally optimal solution is hard to achieve. Here, we developed a genetic algorithm combined with mixed-integer linear programming (MILP) to solve the problem. In this approach, a set of candidate resource allocation strategies, i.e., the choices of the number of resources, are first generated by using MILP. Then, the choices of the type and the cycle time of the resources are evaluated by MILP; the promising ones are used to spawn the next generation of candidate strategies. The effectiveness and efficiency of the developed methodology are illustrated by simulation studies.

1. Introduction

Performance optimization in flexible manufacturing systems has received great attention in recent decades [1]. Such automated systems with synchronization, concurrency, and time delay can usually be modeled by timed marked graphs (TMGs), an important subclass of PNs that are proven to be useful in modeling manufacturing systems, queue systems, and railway transportation systems [2,3,4,5,6,7,8,9,10]. The performance of a system modeled with TMGs is usually characterized by the cycle time that represents the normalized time for one cycle of production. This issue was first studied in ordinary TMG (i.e., TMGs in which the weights on the arcs are unitary). In the literature, ordinary TMGs are simply called “TMGs” by omitting the term “ordinary”. The cycle time can be obtained by exploring the periodic dynamic evolution of a TMG [11]. On the other hand, the exact cycle time of a TMG can also be computed analytically by using the linear programming technique [12]. Algebraic approaches based on (max,+) or (min,+) algebra have also been applied for computing the cycle time of TMGs [13]. Based on these results, various methods have been developed for the performance optimization problems in TMGs, i.e., to minimize the total cost of the system’s resources (machines, devices, tasks, etc.) without compromising the desired level of throughput. The optimization targets include the initial resource allocation [14,15,16,17,18,19,20] and the server-type selection under a given budget [21,22,23].

Timed weighted marked graphs (TWMGs) are more general than ordinary TMGs and are useful in modeling systems with batch processes (i.e., instead of processing tasks one by one, they wait until a batch of tasks are available and process them simultaneously) [24,25]. Nevertheless, obtaining the exact cycle time of a TWMG is much more complicated than that of a TMG. In [26], the authors prove that for a given TWMG, the optimization of the server type is NP-hard. A widely used method for computing the cycle time of a TWMG is to first transform it into an equivalent TMG [27,28] followed by the linear programming technique in [12]. However, such a transformation is computationally heavy, initially marking-dependent, and usually yields a TMG much larger than the original TWMG. To overcome such a problem, in [29], a method is proposed to transform a TWMG (with an undetermined initial marking) into an equivalent parametric TMG so that the scale of the corresponding linear programming remains solvable. Some approximation methods [30] are also developed to estimate the upper bound of the cycle time of a TWMG. A linearization method for TWMGs to obtain linear representation in (min,+) was developed [31]. Based on the obtained linear model, the performance of the TWMGs can be analyzed.

The performance optimization problem in TWMGs is also more complex than that of TMGs. Relatively few works have been conducted on the performance optimization of TWMGs in the literature. Since the equivalent TMG classes of a TWMG is finite, by solving a mixed-integer linear programming problem (MILPP) for each equivalent TMG class, a globally optimal initial marking can be obtained [32,33]. Nevertheless, the computational load of this precise algorithm is unsatisfactory, since the number of equivalent TMG classes is exponential in the number of places in the corresponding TWMG. Therefore, people turn to hybrid algorithms, such as heuristics combined with simulation and MILPPs, which are fast and provide near-optimal solutions [34,35,36]. In [34], a TWMG is initialized with a sufficiently large initial marking so that the performance requirement is satisfied. Then, a greedy algorithm is applied to decrease the total cost in which tokens are iteratively removed until the cycle time reaches a lower bound threshold. A heuristic method combined with integer linear programming was proposed in [35]. However, both heuristics in [34,35] rely on the detection of the so-called critical places and, hence, a time-consuming simulation of the TWMG has to be performed in each iteration. This method is further improved in [36] in which the critical places are determined by linear programming, which greatly improves the efficiency of the heuristic algorithm. Computational efficient solutions for the performance optimization of TWMGs are still missing.

In practice, the execution time of a process may vary when different types of resources (machine, robot, transporting vehicle, etc.) are deployed. Therefore, the optimization of the types and quantities of resources, (so that the performances are maximized) has also received considerable attention in different areas, such as manufacturing systems [37,38,39] and enterprise systems [40]. However, as far as we know, no work has been done on such a problem in TWMGs. Solving this problem is challenging since it is a nonlinear quadratic optimization (which we will see in Section 3) and, thus, a globally optimal solution is hard to achieve. The search space for selecting the types and quantities of resources is quite huge even though the system size is small.

In this paper, we explore the performance optimization problem in TWMGs where both quantities and types of resources are simultaneously optimized. The exact value of the cycle time of TWMGs is efficiently evaluated by using linear algebraic methods. Precisely speaking, our aim is to minimize the cycle time of a given TWMG subject to a given budget limit, while both quantities and types of resources are variables.

The main contribution of this work is summarized as follows. We developed a hybrid method that is a genetic heuristic combined with MILP. Initially, a set of candidate resource allocation strategies, i.e., the choices of the number of resources, are first generated by solving a MILPP. Then, among all of the possible types of resources whose numbers grow exponentially with respect to the system size, we originally developed a MILPP to determine the optimal one. This was done by transforming the determined TWMG of the candidate strategy into an equivalent TMG with parametric firing delays. In the latter, a MILPP was applied to compute its cycle time and the gross cost (scored as fitness). The promising strategies, i.e., those with high fitness, were used to spawn the next generation of candidate strategies. The procedure above was repeated for a pre-set number of generations, and eventually, a near-optimal resource allocation strategy was obtained. Simulation results show that the developed approach can provide a good trade-off between the near-optimality of the solution and the computational load.

This paper is structured as follows. The basic concepts used in this paper are discussed in Section 2. Section 3 formulates the performance optimization problem studied in this paper. In Section 4, a genetic algorithm-based approach is presented. Simulation studies are investigated in Section 5. Conclusions and future work are presented in Section 6.

2. Background

2.1. Generalities

A PN is a 4-tuple $N=(P,T,\mathit{Pre},\mathit{Post})$, where P is a set of n places; T is a set of m transitions; $\mathit{Pre}:P\times T\to \mathbb{N}$ and $\mathit{Post}:P\times T\to \mathbb{N}$ are the pre- and post-incidence functions that specify the arcs, respectively, and are also denoted by matrices in ${\mathbb{N}}^{n\times m}$, where $\mathbb{N}=\{0,1,2,\dots \}$; $\mathit{C}=\mathit{Post}-\mathit{Pre}\in {\mathbb{Z}}^{n\times m}$ is the incidence matrix, where $\mathbb{Z}=\{0,\pm 1,\pm 2,\dots \}$. A PN is said to be ordinary when all of its arc weights are unitary, i.e., $\mathit{Pre},\mathit{Post}\in {\{0,1\}}^{n\times m}$.

A vector $\mathit{y}={(y_1,y_2,\dots ,y_n)}^T\in {\mathbb{N}}^n$ (resp., $\mathit{x}={(x_1,x_2,\dots ,x_m)}^T\in {\mathbb{N}}^m$) such that $\mathit{y}\ne \mathbf{0}$ and ${\mathit{y}}^T·\mathit{C}=\mathbf{0}$ (resp., $\mathit{x}\ne \mathbf{0}$ and $\mathit{C}·\mathit{x}=\mathbf{0}$) is a P-semiflow (resp., T-semiflow). The support of a P-semiflow (resp., T-semiflow) is defined by $\mid \mid \mathit{y}\mid \mid$=$\{p_i\in P\mid y_i>0\}$ (resp., $\mid \mid \mathit{x}\mid \mid$=$\{t_i\in T\mid x_i>0\}$). A P-semiflow $\mathit{y}$ (resp., T-semiflow $\mathit{x}$) is minimal if (i) $\mid \mid \mathit{y}\mid \mid$ (resp., $\mid \mid \mathit{x}\mid \mid$) is not a superset of the support of any other P-semiflow (resp., T-semiflow), and (ii) all $y_i,y_j$ (resp., $x_i,x_j$) where $i\ne j$ are mutually prime.

The set of output (resp., input ) places of transition $t_i\in T$ is defined as $t_i^{•}=\{p\in P\mid Post(p,t_i)>0\}$ (resp., ${}^{•}{t}_i=\{p\in P\mid Pre(p,t_i)>0\}$). The notions for ${}^{•}p$ and $p^{•}$ are analogously defined.

A marking is a mapping $\mathit{M}:P\to \mathbb{N}$ that assigns to each place of a PN a non-negative integer number of tokens, which is also described as an n-component vector $\mathit{M}\in {\mathbb{N}}^n$. The number of tokens of place p at marking $\mathit{M}$ is denoted by $M\left(p\right)$. A Petri net system $\langle N,{\mathit{M}}_{\mathbf{0}}\rangle$ is a net N with an initial marking ${\mathit{M}}_{\mathbf{0}}$.

A weighted marked graph (WMG) is a PN in which each place has exactly one input and one output transition. A marked graph (MG) is a WMG whose weights on arcs are unitary.

Given a PN N, a path is a sequence of nodes $o_1{o}_2\cdots o_q$ where $o_i\in P\cup T$ for all $i\in \{1,\dots ,q\}$ and $o_{i+1}\in o_i^{•}$ holds for all $i\in \{1,\dots ,q-1\}$. A PN is said to be strongly connected if, for any $o,o^{\prime }\in P\cup T$, there exists a path from o to $o^{\prime }$. A path $o_1{o}_2\cdots o_q$ is a circuit if $o_1=o_q$. A circuit $o_1{o}_2\cdots o_{q-1}{o}_1$ is an elementary circuit, denoted by $\gamma$, if for all $i,j\in \{1,\dots ,q\}$, $i\ne j$ indicates $o_i\ne o_j$. The set of all elementary circuits of N is denoted by $\mathrm{\Gamma }$.

A WMG is neutral if for each elementary circuit $\gamma$ it holds that ${\prod }_{p_j\in \gamma }\frac{Pre(p_j,p_j^{•})}{Post(p_j,{}^{•}{p}_j)}=1$. In the rest of this paper, we limit our study to neutral and strongly connected WMGs.

2.2. Timed Petri Nets

In the literature, two types of timed Petri nets (TPNs) [41] are mainly studied, namely transition-timed PNs (TTPNs) and place-timed PNs (PTPNs) [42]. A transition-timed Petri net is a pair $N_d$ = $(N,\mathit{\delta })$ where

• $N=(P,T,\mathit{Pre},$$\mathit{Post})$ is a PN;
• $\mathit{\delta }={[\delta \left(t_1\right),\delta \left(t_2\right),\dots ,\delta \left(t_m\right)]}^T\in {\mathbb{Q}}_{\ge 0}^m$ is an m-component vector, called the firing delay vector of $N_d$, which assigns a non-negative rational value to each transition to represent its firing delay, where $\mathbb{Q}$ denotes the set of rational numbers.

For a PTPN, a non-negative rational duration $\delta \left(p\right)$ is assigned to each place p to represent the residual time that a token must spend in p before it becomes available for its output transitions.

Given a TTPN $N_d=(N,\mathit{\delta })$, the enabling degree of a transition t logically enabled at a marking $\mathit{M}$, denoted as $en(\mathit{M},t)$, is the largest integer r, such that $r·\mathit{Pre}(·,t)\le \mathit{M}$. The TTPNs considered in this paper follow the so-called infinite server semantics [42]. In plain words, each transition represents an operation that can be executed as many times as the number of available servers, i.e., each enabled transition can fire as many times as its enabling degree.

A TTPN $(N,\mathit{\delta })$ is called a TWMG if net N is a weighted marked graph. A TWMG system is a triple $G=\langle N,\mathit{\delta },{\mathit{M}}_0\rangle$, where $(N,\mathit{\delta })$ is a TWMG and ${\mathit{M}}_{\mathbf{0}}$ is an initial marking.

2.3. Cycle Time of TWMGs

The cycle time of a TWMG system $G=\langle N,\mathit{\delta },{\mathit{M}}_0\rangle$, denoted by $\chi \left(G\right)$, is the average period to fire one time the minimal T-semiflow $\mathit{x}=[x_1,\dots ,x_m]$ [28,34]. The steady evolution of a strongly connected TWMG system is repetitive. Let $f_i$ denote the firing frequency of transition $t_i$ during the repetitive period. Then, the cycle time of a TWMG system $G=\langle N,\mathit{\delta },{\mathit{M}}_0\rangle$ can be defined as:

$$\chi \left(G\right)=\frac{x_i}{f_i},\forall t_i\in T.$$

(1)

We denote by ${\chi }_{\gamma }\left(G\right)$ the cycle time of elementary circuit $\gamma$ and by ${\chi }_{{\gamma }^{*}}\left(G\right)=\underset{\gamma \in \mathrm{\Gamma }}{max}{\chi }_{\gamma }\left(G\right)$ the critical time. For a TMG system, the cycle time is equal to the critical time, i.e.,

$$\chi \left(G\right)={\chi }_{{\gamma }^{*}}\left(G\right).$$

However, for a TWMG system, reference [35] shows that the cycle time is greater than or equal to the critical time, i.e.,

$$\chi \left(G\right)\ge {\chi }_{{\gamma }^{*}}\left(G\right).$$

The cycle time of a TWMG can be determined by the simulation. The work of [12,30] provides a lower bound and an upper bound of the cycle times that are easy to compute. However, in general, such approximations may be far from the actual cycle time and, hence, cannot be used as guidelines for performance optimization. On the other hand, a TWMG system $G=\langle N,\mathit{\delta },\mathit{M}\rangle$ can be transformed into an equivalent place-timed marked graphs (PTMGs) system $\widehat{G}=\langle \widehat{N},\widehat{\mathit{\delta }},\widehat{\mathit{M}}\rangle$ as shown in Algorithm 1, which describes the same behavior, transition firing language, and cycle time [28]. Then, the cycle time $\chi \left(G\right)$ of the original TWMG system can be obtained by solving the following linear programming problem (LPP) for the equivalent PTMG system $\widehat{G}$ [12,33]:

$$\begin{array}{cc}\hfill & min\chi \left(\widehat{G}\right)\hfill \\ \mathrm{s}.\mathrm{t}.\hfill & \widehat{\mathit{C}}·\mathbf{\alpha }+\chi \left(\widehat{G}\right)·\widehat{\mathit{M}}\ge {\mathit{D}}_p·\widehat{\mathit{Post}}·\mathit{v}\hfill \end{array}$$

(2)

where $\chi \left(G\right)=\chi \left(\widehat{G}\right)\in {\mathbb{R}}^{+}$, $\mathbf{\alpha }\in {\mathbb{R}}^{\widehat{m}}$, $\mathit{v}={\overrightarrow{\mathbf{1}}}_{\widehat{m}\times 1}$ is the visit ratio vector, and ${\mathit{D}}_p\in {\mathbb{N}}^{\widehat{n}\times \widehat{n}}$ is a diagonal matrix such that

$$D_p(i,j)=\left\{\begin{array}{cc}\widehat{\delta }\left(p_i\right),\hfill & \mathrm{if}i=j,\hfill \\ 0,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(3)

Note that $t_{in\left(p_j\right)}$, $t_{out\left(p_j\right)}$, $\lfloor ·\rfloor$, and $\lceil ·\rceil$ in Algorithm 1 represent the unique input transition of place $p_j$, the unique output transition of place $p_j$, the floor operator, and the ceiling operator, respectively.

Algorithm 1 Transformation of a TWMG into a PTMG [12].

Input: A TWMG system $G=\langle N,\mathit{\delta },\mathit{M}\rangle$ and the minimal T-semiflow $\mathit{x}={(x_1,\dots ,x_m)}^T$ of net N; Output: An equivalent PTMG system $\widehat{G}=\langle \widehat{N},\widehat{\mathit{\delta }},\widehat{\mathit{M}}\rangle$ such that $\chi \left(\widehat{G}\right)=\chi \left(G\right)$; for each transition $t_i\in T$ do      delete $t_i$ and its corresponding arcs;     add $x_i$ transitions $t_i^1$, $t_i^2$, …, $t_i^{x_i}$ and $x_i$ places $q_i^1$, $q_i^2$, …, $q_i^{x_i}$ such that ${}^{•}{q}_i^a=t_i^a$, ${q_i^a}^{•}=t_i^{a\mathrm{mod}{x}_i+1}$, $\forall a=1,\dots ,x_i$;      $$\mathrm{let}\left\{\begin{array}{l}\widehat{M}\left(q_i^1\right)=\widehat{M}\left(q_i^2\right)=\cdots =\widehat{M}\left(q_i^{x_i-1}\right):=0,\\ \widehat{M}\left(q_i^{x_i}\right):=1,\\ \widehat{\delta }\left(q_i^1\right)=\widehat{\delta }\left(q_i^2\right)=\cdots =\widehat{\delta }\left(q_i^{x_i}\right):=0.\end{array}\right.$$ (4) end for for each place $p_j\in P$ begin do     delete $p_j$ and its corresponding arcs;     let $a:=0$, $s:=1$;     repeat          $$b:=⌊\frac{M\left(p_j\right)+Post(p_j,t_{in\left(p_j\right)})·a}{Pre(p_j,t_{out\left(p_j\right)})}+1⌋$$ (5) $$\begin{array}{c}\hfill a:=⌈\frac{Pre(p_j,t_{out\left(p_j\right)})·b-M\left(p_j\right)}{Post(p_j,t_{in\left(p_j\right)})}⌉\end{array}$$ (6)         if $a\le x_{in\left(p_j\right)}$ then            Add place $p_j^s$ such that ${}^{•}{p}_j^s=t_{in\left(p_j\right)}^a$, ${p_j^s}^{•}=t_{out\left(p_j\right)}^{(b-1)\mathrm{mod}{x}_{out\left(p_j\right)}+1}$             $$\widehat{M}\left(p_j^s\right):=⌊\frac{b-1}{x_{out\left(p_j\right)}}⌋$$ (7) $$\widehat{\delta }\left(p_j^s\right):=\delta \left(t_{in\left(p_j\right)}\right)$$ (8)             $$n_j:=s$$ (9)            $s:=s+1$         end if     until $a\ge x_{in\left(p_j\right)}$ end for

3. Problem Statement

In a TWMG that models a practical system, each transition $t_i$ models an operation performed by machines, robots, etc., which we call the servers. A server is modeled by a server place $p_{s_i}$ self-looped with $t_i$. We consider the performance optimization problem in TWMGs where both quantities and types of servers are variables to be simultaneously optimized. Precisely speaking:

• For each transition, $t_i$ with $k_i\in {\mathbb{N}}_{>0}$ choices of server types, we use a $k_i$-component binary vector ${\mathit{Z}}_i={[Z_i\left(1\right),Z_i\left(2\right),\dots ,Z_i\left(k_i\right)]}^T\in {\{0,1\}}^{k_i}$ to describe the server type selection of it, where

  $$Z_i\left(j\right)=\left\{\begin{array}{cc}1,\hfill & \mathrm{the}j\mathrm{-th}\mathrm{type}\mathrm{of}\mathrm{server}\mathrm{is}\mathrm{selected},\hfill \\ 0,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$
  Moreover, to ensure that the operation is consistent, we require that—among all of the $k_i$ types of servers of transition $t_i$—only one type can be selected, i.e.,    

  $$Z_i\left(1\right)+Z_i\left(2\right)+\cdots +Z_i\left(k_i\right)=1$$
• For each transition $t_i$, different servers have different performances (i.e., the firing delay) and costs. We use $\delta (t_i,j)$ and $\lambda (t_i,j)$ ($j\in \{1,\dots ,k_i\}$) to denote the firing delay and the unit cost of server type j, respectively. We denote the firing delay vector of transition $t_i$ and the unit cost vector of transition $t_i$ by $\mathit{\delta }\left(t_i\right)={[\delta (t_i,1),\delta (t_i,2),\dots ,\delta (t_i,k_i)]}^T\in {\mathbb{Q}}_{\ge 0}^{k_i}$, and $\mathit{\lambda }\left(t_i\right)={[\lambda (t_i,1),\lambda (t_i,2),\dots ,\lambda (t_i,k_i)]}^T\in {\mathbb{Q}}_{\ge 0}^{k_i}$, respectively.
• For each transition $t_i$, we use $M\left(p_{s_i}\right)$ to denote the server quantity of it, i.e., the number of servers to equip. Then, we use $\mathcal{M}={[M\left(p_{s_1}\right),M\left(p_{s_2}\right),\dots ,M\left(p_{s_m}\right)]}^T\in {\mathbb{N}}^m$ to represent the server quantity of all servers in the gross TWMG system.

Therefore, the firing delay $\delta \left(t_i\right)$ and the unit cost $\lambda \left(t_i\right)$ of transition $t_i$ are determined by the following equation:

$$\begin{array}{c}\lambda \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\lambda }\left(t_i\right),\hfill \\ \delta \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\delta }\left(t_i\right),\hfill \\ Z_i\left(1\right)+Z_i\left(2\right)+\dots +Z_i\left(k_i\right)=1,\hfill \\ i=1,\dots ,m.\hfill \end{array}$$

(10)

Moreover, the choices of server types and quantities must be subject to a given budget limit $R\in \mathbb{R}$. Then, we can formulate the performance optimization problem as the following.

Problem 1 

(Performance optimization problem). Given a TWMG model N, a budget $R\in \mathbb{R}$, a unit cost vector $\mathit{\lambda }\left(t_i\right)$, and a firing delay vector $\mathit{\delta }\left(t_i\right)$, determine a server-type selection ${\mathit{Z}}_i={[Z_i\left(1\right),Z_i\left(2\right),\dots ,Z_i\left(k_i\right)]}^T$ and a server quantity $\mathcal{M}={[M\left(p_{s_1}\right),M\left(p_{s_2}\right),\dots ,M\left(p_{s_m}\right)]}^T$, such that ${\mathit{\lambda }}^T·\mathcal{M}\le R$ while the cycle time $\chi \left(G\right)$ is minimized (i.e., the performance is maximized).

In plain words, solving Problem 1 is equivalent to solving the following optimization problem

$$\begin{array}{cc}\hfill & min\chi \left(G\right)\hfill \\ \mathrm{s}.\mathrm{t}.\hfill & \left\{\begin{array}{c}{\mathit{\lambda }}^T·\mathcal{M}\le R,\left(11\mathrm{a}\right)\hfill \\ \left.\begin{array}{c}\lambda \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\lambda }\left(t_i\right),\hfill \\ \delta \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\delta }\left(t_i\right),\hfill \\ Z_i\left(1\right)+Z_i\left(2\right)+\dots +Z_i\left(k_i\right)=1,\hfill \\ i=1,\dots ,m,\hfill \end{array}\right\}\left(11\mathrm{b}\right)\hfill \end{array}\right.\hfill \end{array}$$

(11)

where

• $\chi \left(G\right)$ represents the cycle time of the TWMG system $G=\langle N,\mathit{\delta },\mathit{M}\rangle$,
• $\mathit{\lambda }={[\lambda \left(t_1\right),\dots ,\lambda \left(t_m\right)]}^T$ represents the cost vector of the TWMG,
• $\mathcal{M}={[M\left(p_{s_1}\right),\dots ,M\left(p_{s_m}\right)]}^T$ is the server quantity of the TWMG,
• $\mathit{\delta }={[\delta \left(t_1\right),\dots ,\delta \left(t_m\right)]}^T$ is the firing delay vector of the TWMG.

However, we note that solving this problem is challenging since it is a quadratic optimization: in general, a globally optimal solution is hard to achieve. Therefore, in the next section, we develop a hybrid method composed of genetic heuristics and MILP. The following example will be used as a running example in the sequel of this paper.

Example 1. 

Consider the TWMG model N depicted in Figure 1 that represents a cyclic manufacturing system. It is composed of two different operations performed by machines ${\mathcal{MA}}_1$ and ${\mathcal{MA}}_2$, respectively. Transitions $t_1$ and $t_2$ represent the operation performed by machines ${\mathcal{MA}}_1$ and ${\mathcal{MA}}_2$, respectively. Place $p_1$ is an idle place that represents the raw material to proceed, place $p_2$ is an activity place that represents the manufacturing process, and places $p_{s_1}$ and $p_{s_2}$ are the server places corresponding to $t_1$ and $t_2$, respectively. Tokens in places $p_{s_1}$ and $p_{s_2}$ represent the numbers of machines ${\mathcal{MA}}_1$ and ${\mathcal{MA}}_2$, respectively. Initially, there are one hundred raw materials to be proceeded, i.e., $M\left(p_1\right)=100$, and no semi-products are being produced, i.e., $M\left(p_2\right)=0$.

Assume that we have $k_1=3,k_2=2$, i.e., transition $t_1$ has three choices of server types and transition $t_2$ has two choices. The firing delay and the unit cost of each type choice are listed in

Table 1. The unit cost and the firing delays of each server on the transitions for Example 1.

Transition	Server Type	Unit Cost of Server Type j	Firing Delay
${\mathit{t}}_{\mathit{i}}$	j	$\mathit{\lambda }({\mathit{t}}_{\mathit{i}},\mathit{j})$	$\mathit{\delta }({\mathit{t}}_{\mathit{i}},\mathit{j})$ [s]
$t_1$	1	4	15
	2	10	4
	3	15	2
$t_2$	1	5	20
	2	9	18

.

$$\left\{\begin{array}{c}\mathit{\lambda }\left(t_1\right)={[\lambda (t_1,1),\lambda (t_1,2),\lambda (t_1,3)]}^T={[4,10,15]}^T,\hfill \\ \mathit{\lambda }\left(t_2\right)={[\lambda (t_2,1),\lambda (t_2,2)]}^T={[5,9]}^T,\hfill \\ \mathit{\delta }\left(t_1\right)={[\delta (t_1,1),\delta (t_1,2),\delta (t_1,3)]}^T={[15,4,2]}^T,\hfill \\ \mathit{\delta }\left(t_2\right)={[\delta (t_2,1),\delta (t_2,2)]}^T={[20,18]}^T.\hfill \end{array}\right.$$

The performance optimization problem (11) is to determine the quantities of servers of transitions $\mathcal{M}={[M\left(p_{s_1}\right),M\left(p_{s_2}\right)]}^T$ and the server-type selections ${\mathit{Z}}_1=[Z_1\left(1\right),Z_1\left(2\right),Z_1\left(3\right)]$ and ${\mathit{Z}}_2=[Z_2\left(1\right),Z_2\left(2\right)]$ subject to a given budget R so that the cycle time of the system is minimized.

4. Genetic MILP Approach for Performance Optimization in TWMGs

Due to the existence of weights on arcs of the TWMGs and the nonlinear constraint (11a), it is quite difficult to find an analytical approach to solve problem (11). Hence, in this section, we develop a hybrid method composed of genetic heuristics and mixed-integer linear programming, which makes the problem solvable.

As mentioned before, a possible server allocation strategy consists of two parts $(\mathcal{M},\mathit{Z})$ where $\mathcal{M}$ characterizes the choice of the quantity while $\mathit{Z}=({\mathit{Z}}_1,\dots ,{\mathit{Z}}_m)$ characterizes the choice of the server type. In our method, the two parts are optimized in an alternative manner. For small systems, it could be possible to enumerate the server type $\mathit{Z}$ first and determine the quantity $\mathcal{M}$ subsequently. However, it is not possible for practical systems even with medium sizes. In addition, it was shown in [33] that for a TWMG whose server type $\mathit{Z}$ is given, the optimal quantity $\mathcal{M}$ can be obtained by transforming it into a finite number of equivalent PTMG classes and solving a MILPP for each equivalent class. The computational cost of this approach is high since the number of equivalent PTMG classes increases exponentially w.r.t. the number of places of the original TWMG. In practice, it is inefficient to solve the performance optimization in TWMGs by exploring all the equivalent PTMGs.

In this paper, the quantity-component $\mathcal{M}$, i.e., the initial token distribution for server places in the TWMG, is first treated as a chromosome in the genetic heuristics. Then, among all the possible server types $\mathit{Z}$ whose number grows exponentially with respect to the system size, we originally develop a MILPP to determine the optimal one. Therefore, the computational cost can be reduced significantly compared with the existing methods in [33]. Moreover, the result from the MILPP is also used to score the chromosome, i.e., the fitness of the quantity–component $\mathcal{M}$, which provides a guideline for generating the next generation of candidate chromosomes. This alternated optimization is done when a pre-given number ($Ge$) that represents the maximum number of generation is reached. The main steps of the approach are sketched in the flow chart in Figure 2.

In the following subsections, we will discuss the main elements of the developed approach:

• Coding and decoding;
• Initial population generation;
• Calculation of the objective function and fitness value;
• The overall genetic algorithm: selection, crossover, and mutation.

4.1. Coding and Decoding

A server allocation strategy (i.e., server quantity) $\mathcal{M}$ can be coded as a chromosome $\mathit{Chm}$ that is an m-dimensional nonnegative integer vector such that

$$\mathit{Chm}={[e_1,e_2,\dots ,e_m]}^T=\mathcal{M},$$

(12)

where $e_i$ represents the quantities of servers of transition $t_i$, i.e., the number of tokens in the server place $p_i^s$. For instance, the chromosome of the TWMG model N depicted in Figure 1 can be expressed as $\mathit{Chm}={[e_1,e_2]}^T$, where $e_1=M\left(p_1^s\right)$ and $e_2=M\left(p_1^2\right)$. Therefore, we can decode $\mathit{Chm}$ into a marking ${\mathit{M}}_{\mathit{Chm}}={[4,0,e_1,e_2]}^T$ of the TWMG model.

4.2. Population Generation and Feasibility Screening

In each iteration in the genetic algorithm, a set of candidate chromosomes are generated from promising ones in the previous generation. However, not all of the newly generated chromosomes—in our case the initial server distribution—are feasible. For example, some initial server distribution may result in the system eventually dying. Hence, a pre-screening step is performed to remove such unfeasible chromosomes from the pool of candidates.

First, a marking ${\mathit{M}}_{\mathit{Chm}}$ that is decoded by a chromosome $\mathit{Chm}$ should guarantee the liveness of a TWMG. A TWMG is live if and only if each elementary circuit is live [24]. Hence, a feasible chromosome necessarily satisfies the following condition:

$$(\forall \gamma \in \mathrm{\Gamma }){\mathit{y}}^T·{\mathit{M}}_{\mathit{Chm}}>{\mathit{y}}^T·{\mathit{M}}_D^{\gamma }$$

(13)

where $\mathit{y}$ is the minimal T-semiflow corresponding to $\gamma$ and ${\mathit{M}}_D^{\gamma }=[Pre(p_1,p_1^{•})-1,\dots ,$$Pre(p_n,p_n^{•}){-1]}^T$ is a marking restricted to $\gamma$.

On the other hand, a chromosome $\mathit{Chm}$ is feasible only if there exists at least one server-type selection ${\mathit{Z}}_i=[Z_i\left(1\right),\dots ,Z_i\left(k_i\right)]$ for every transition $t_i\in T$, such that the total cost of servers does not beyond the budget R. This indicates that the following constraint is necessarily feasible:

$$\left\{\begin{array}{c}{\mathit{\lambda }}^T·\mathcal{M}\le R,\hfill \\ \mathcal{M}=\mathit{Chm},\hfill \\ \lambda \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\lambda }\left(t_i\right),\hfill \\ Z_i\left(1\right)+Z_i\left(2\right)+\dots +Z_i\left(k_i\right)=1,\hfill \end{array}\right.$$

(14)

Combining the results in (13) and (14), both the liveness and feasibility of a chromosome $\mathit{Chm}$ can be guaranteed by the following constraints:

$$\left\{\begin{array}{c}\mathit{y}·{\mathit{M}}_{\mathit{Chm}}>\mathit{y}·{\mathit{M}}_D^{\gamma },\forall \gamma \in \mathrm{\Gamma },\hfill \\ {\mathit{\lambda }}^T·\mathcal{M}\le R,\hfill \\ \mathcal{M}=\mathit{Chm},\hfill \\ \lambda \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\lambda }\left(t_i\right),\hfill \\ Z_i\left(1\right)+Z_i\left(2\right)+\dots +Z_i\left(k_i\right)=1,\hfill \end{array}\right.$$

(15)

where ${\mathit{M}}_{\mathit{Chm}}$ is a marking decoded from chromosome $\mathit{Chm}$.

4.3. Objective Function and Fitness Score: A MILPP Approach

Given a chromosome $\mathit{Chm}$ and its decoded marking ${\mathit{M}}_{\mathit{Chm}}$ of a TWMG model N, we aim to determine the optimal server-type selection $\mathit{Z}=({\mathit{Z}}_1,\dots ,{\mathit{Z}}_m)$, such that the cycle time $\chi \left(G\right)$ of the TWMG system $G=\langle N,\mathit{\delta },{\mathit{M}}_{\mathit{Chm}}\rangle$ is minimized while the cost of the servers corresponding to $(\mathcal{M},\mathit{Z})$ do not exceed the budget R.

As we discussed in Section 2.3, a TWMG system $G=\langle N,\mathit{\delta },{\mathit{M}}_{\mathit{Chm}}\rangle$ with a known initial marking ${\mathit{M}}_{\mathit{Chm}}$ can be transformed into an equivalent PTMG system $\widehat{G}=\langle \widehat{N},\widehat{\mathit{\delta }},{\widehat{\mathit{M}}}_{Chm}\rangle$ with the same cycle time. Hence, the cycle time $\chi \left(G\right)$ of G can be obtained by solving LPP (2) for its equivalent PTMG system $\widehat{G}$. Note that here the firing delay vector $\mathit{\delta }={[\delta \left(t_1\right),\dots ,\delta \left(t_m\right)]}^T$ of G is dependent on the server-type selection $\mathit{Z}$ which is undetermined yet. Hence, the firing delays in the corresponding equivalent PTMG system $\widehat{G}$$\widehat{\mathit{\delta }}=[\widehat{\delta }\left(p_1\right),\dots ,\widehat{\delta }\left(p_{\widehat{n}}\right)]$ is also to be determined. Now we show such an optimal server-type selection can be obtained by solving a MILPP for the equivalent PTMG.

Proposition 1. 

Given a performance optimization problem (11) for a TWMG system G whose equivalent PTMG system is $\widehat{G}$, let $(\chi \left(\widehat{G}\right),\mathbf{\alpha },\mathit{\lambda },\mathit{\delta },\widehat{\mathit{\delta }},{\mathit{D}}_p,{\mathit{Z}}_i)$ be the optimal solution of the following MILPP:

$$\begin{array}{cc}\hfill & min\chi \left(\widehat{G}\right)\hfill \\ s.t.\hfill & \left\{\begin{array}{l}\widehat{\mathit{C}}·\mathbf{\alpha }+\chi \left(\widehat{G}\right)·{\widehat{\mathit{M}}}_{\mathit{Chm}}\ge {\mathit{D}}_p·\widehat{\mathit{Post}}·\mathit{v},\left(16\mathrm{a}\right)\hfill \\ \left.\begin{array}{c}{\mathit{\lambda }}^T·\mathcal{M}\le R,\hfill \\ \mathcal{M}=\mathit{Chm},\hfill \end{array}\right\}\left(16\mathrm{b}\right)\hfill \\ \left.\begin{array}{c}\lambda \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\lambda }\left(t_i\right),\hfill \\ \delta \left(t_i\right)={\mathit{Z}}_i^T·\mathit{\delta }\left(t_i\right),\hfill \end{array}\right\}\left(16\mathrm{c}\right)\hfill \\ Z_i\left(1\right)+Z_i\left(2\right)+\dots +Z_i\left(k_i\right)=1,\left(16\mathrm{d}\right)\hfill \\ i=1,\dots ,m,\left(16\mathrm{e}\right)\hfill \\ \left.\begin{array}{c}\widehat{\delta }\left(q_i^a\right)=0,a=1,\dots ,x_i,\hfill \\ \widehat{\delta }\left(p_j^s\right)=\delta \left(t_q\right),{\forall }^{•}{p}_j=t_q,s=1,\dots ,n_j\hfill \end{array}\right\}\left(16\mathrm{f}\right)\hfill \end{array}\right.\hfill \end{array}$$

(16)

Then, ${\mathit{Z}}_i$ ($i=1,\dots ,m$) is an optimal server-type selection of problem (11) with respect to a given server quantity $\mathcal{M}=\mathit{Chm}$.

Proof. 

Constraint (16b) ensures that the choice of server types subject to server quantity $\mathcal{M}=\mathit{Chm}$ does not exceed the budget R. Constraints (16c), (16d), and (16e) jointly enforce Equation (10). Combining the results in Equations (2) and (6), constraint (16f) ensures the correctness of the firing delay equivalence between the original TWMG and the PTMG. According to the results in [12,33], constraint (16a) can provide an optimal solution for performance optimization if $\widehat{\mathit{C}}$ and ${\mathit{M}}_{\mathit{Chm}}$ are given. Therefore, ${\mathit{Z}}_i$ ($i=1,\dots ,m$) is an optimal server-type selection of problem (11) restricted to a given server quantity $\mathcal{M}=\mathit{Chm}$.    □

Given a chromosome $\mathit{Chm}$, the cycle time $\chi \left(\widehat{G}\right)$ in the optimal solution of MILPP (16) is denoted as $F\left({\mathit{M}}_{\mathit{C}hm}\right)={\chi }^{*}$. Let ${\mathcal{N}}_i$ denote the pool of chromosomes in the i-th iteration, i.e., the i-th generation, we define

$$F_{min}=\underset{\mathit{Chm}\in {\mathcal{N}}_i}{min}F\left(\mathit{Chm}\right)$$

and

$$F_{max}=\underset{\mathit{Chm}\in {\mathcal{N}}_i}{max}F\left(\mathit{Chm}\right)$$

the minimum and maximum objective functions (i.e., cycle time) of the population in the current generation, respectively. Then, the fitness of a chromosome $\mathit{Chm}$ is defined as

$$fitness\left(\mathit{Chm}\right)=1-\frac{F\left(\mathit{Chm}\right)-F_{min}}{F_{max}-F_{min}}$$

(17)

Example 2. 

Let us consider again the TWMG model N discussed in Example 1 with a minimal T-semiflow $\mathit{x}={[3,2]}^T$ and a chromosome $\mathit{Chm}={[4,5]}^T$. Then, the decoded initial marking is ${\mathit{M}}_{\mathit{C}hm}={[100,0,4,5]}^T$. The equivalent PTMG system $\widehat{G}=\langle \widehat{N},\widehat{\mathit{\delta }},{\widehat{\mathit{M}}}_{\mathit{C}hm}\rangle$ corresponding to ${\mathit{M}}_{\mathit{C}hm}$ is shown in Figure 3, where the firing delay vector $\widehat{\mathit{\delta }}$ is to be determined.

Let $R=100$ be the budget limit. According to Proposition 1, a MILPP can be established as shown in Equation (18). By solving MILPP (18), we obtain $\mathit{Z}=({\mathit{Z}}_1,{\mathit{Z}}_2)$ where ${\mathit{Z}}_1={[0,1,0]}^T$ and ${\mathit{Z}}_2={[0,1]}^T$. Thus, to optimize the performance of the PTMG (which is equal to that of the original TWMG), transition $t_1$ should be equipped with the second type of server while transition $t_2$ should be equipped with the second type. The optimal cycle time $\chi \left(G\right)=\chi \left(\widehat{G}\right)=7.2$ of the TWMG system $G=\langle N,,\mathit{\delta },{\mathit{M}}_{\mathit{Chm}}\rangle$. Finally, the objective function of chromosome $\mathit{Chm}={[4,5]}^T$ is $F\left(\mathit{Chm}\right)=7.2$, and its fitness can be computed according to Equation (17).

$$\begin{array}{c}min\chi \left(\widehat{G}\right)\hfill \\ s.t.\left\{\begin{array}{c}\widehat{\mathit{C}}·\mathbf{\alpha }+\chi \left(\widehat{G}\right)·{\widehat{\mathit{M}}}_{\mathit{Chm}}\ge {\mathit{D}}_p·\widehat{\mathit{Post}}·\mathit{v},\hfill \\ \left.\begin{array}{c}{\mathit{\lambda }}^T·\mathcal{M}\le R,\hfill \\ \mathcal{M}=\mathit{Chm},\hfill \end{array}\right\}\hfill \\ \left.\begin{array}{c}\lambda \left(t_1\right)=Z_1\left(1\right)·\lambda (t_1,1)+Z_1\left(2\right)·\lambda (t_1,2)+Z_1\left(3\right)·\lambda (t_1,3),\hfill \\ \delta \left(t_1\right)=Z_1\left(1\right)·\delta (t_1,1)+Z_1\left(2\right)·\delta (t_1,2)+Z_1\left(3\right)·\delta (t_1,3),\hfill \\ \lambda \left(t_2\right)=Z_2\left(1\right)·\lambda (t_2,1)+Z_2\left(2\right)·\lambda (t_2,2),\hfill \\ \delta \left(t_2\right)=Z_2\left(1\right)·\delta (t_2,1)+Z_2\left(2\right)·\delta (t_2,2),\hfill \end{array}\right\}\hfill \\ \left.\begin{array}{c}{Z}_1\left(1\right)+Z_1\left(2\right)+Z_1\left(3\right)=1,\hfill \\ Z_2\left(1\right)+Z_2\left(2\right)=1,\hfill \end{array}\right\}\hfill \\ i=1,2,\hfill \\ \left.\begin{array}{c}\widehat{\delta }\left(q_1^1\right)=0,\widehat{\delta }\left(q_1^2\right)=0,\widehat{\delta }\left(q_1^3\right)=0,\hfill \\ \widehat{\delta }\left(q_2^1\right)=0,\widehat{\delta }\left(q_2^2\right)=0,\hfill \\ \widehat{\delta }\left(p_1^1\right)=\delta \left(t_2\right),\widehat{\delta }\left(p_1^2\right)=\delta \left(t_2\right),\hfill \\ \widehat{\delta }\left(p_2^1\right)=\delta \left(t_1\right),\widehat{\delta }\left(p_2^2\right)=\delta \left(t_1\right),\hfill \\ \widehat{\delta }\left(p_{s_1}^1\right)=\delta \left(t_1\right),\widehat{\delta }\left(p_{s_1}^2\right)=\delta \left(t_1\right),\hfill \\ \widehat{\delta }\left(p_{s_1}^3\right)=\delta \left(t_1\right),\hfill \\ \widehat{\delta }\left(p_{s_2}^1\right)=\delta \left(t_2\right),\widehat{\delta }\left(p_{s_2}^2\right)=\delta \left(t_2\right),\hfill \end{array}\right\}\hfill \end{array}\right.\hfill \end{array}$$

(18)

4.4. The Overall Genetic Algorithm

Now we are ready to introduce the overall genetic algorithm in our approach.

4.4.1. Selection

The purpose of the selection operation is to save chromosomes with higher fitness values in the parent population and to eliminate chromosomes with low fitness values. The selection rule we used here combines the classical roulette wheel selection [43] (also called the proportional selection, which ensures the diversity of genes inherited by the next generation) and the optimal retention [43] (that can effectively retain the optimal individual of each generation). In a roulette selection, the probability of each chromosome $\mathit{Chm}$ to be selected is proportional to its fitness value $fitness\left(\mathit{Chm}\right)$. In generation i with population ${\mathcal{N}}_i$, the probability of selecting a chromosome $\mathit{C}hm$ is given by:

$$Prob\left({\mathit{Chm}}_i\right)=\frac{fitness\left(\mathit{Chm}\right)}{{\sum }_{{\mathit{Chm}}_j\in {\mathcal{N}}_i}fitness\left({\mathit{Chm}}_j\right)}.$$

(19)

Note that it may eliminate chromosomes with large fitness values during the roulette wheel selection operation. Therefore, we retain the chromosome with the highest fitness value through the optimal retention method before the roulette wheel selection operation.

4.4.2. Crossover

In the genetic algorithm, new chromosomes are generated through the crossover operation by exchanging gene segments from two parent chromosomes to find better offspring. In the literature, several crossover operations have been proposed, such as single-point crossover, multi-point crossover, and uniform crossover [43]. In this paper, we used a single-point crossover operation for the genetic algorithm.

4.4.3. Mutation

The mutation operation is to randomly—usually with a pre-set probability—perturb one or several genes of a chromosome. The mutation operation is of great significance in the genetic algorithm to maintain population diversity, prevent falling into the local optimal solution, and enrich the gene pool. The mutation operation uses site mutation, i.e., one or more genes of a chromosome are randomly selected and changed with a mutation probability. In this paper, we use the single-point mutation operation, i.e., at most one gene in each chromosome is mutated for each operation.

Note that during the crossover operation and mutation operation, a newly generated chromosome $\mathit{Chm}$ may not always satisfy the constraints in Equation (15), i.e., the TWMG may not be live at the decoded marking ${\mathit{M}}_{\mathit{Chm}}$, or the total cost of servers corresponding to ${\mathit{M}}_{\mathit{Chm}}$ exceeds the budget. In such a case, the chromosome that leads to an infeasible solution is immediately discarded, and a fully randomized chromosome, which satisfies the constraint (15) is added to the pool.

The entire hybrid method that combines genetic heuristics with MILP is presented as Algorithm 2, whose inputs are: a TWMG model N, the budget R, the unit cost vector $\mathit{\lambda }\left(t_i\right)$, the firing delay vector $\mathit{\delta }\left(t_i\right)$, the population size ${\mathcal{N}}_p$ (i.e., $\mathcal{N}$), the maximum number of generations $Ge$, the crossover probability ${\mathcal{P}}_c$, and the mutation probability ${\mathcal{P}}_m$.

Algorithm 2 Genetic MILP method for performance optimization in TWMGs.

Input: A TWMG model N, $R\in \mathbb{R}$, $\mathit{\lambda }\left(t_i\right)\in {\mathbb{Q}}_{\ge 0}^m$, $\mathit{\delta }\left(t_i\right)\in {\mathbb{Q}}_{\ge 0}^m$, ${\mathcal{N}}_p\in \mathbb{N}$, $Ge\in \mathbb{N}$, ${\mathcal{P}}_c\in {\mathbb{R}}_{\ge 0}$, ${\mathcal{P}}_m\in {\mathbb{R}}_{\ge 0}$, ${\mathcal{T}}_0\in {\mathbb{R}}_{\ge 0}$, ${\mathcal{T}}_e\in {\mathbb{R}}_{\ge 0}$, and $\epsilon \in {\mathbb{R}}_{\ge 0}$; Output: Server-type selection $\mathit{Z}={[{\mathit{Z}}_1,\dots ,{\mathit{Z}}_m]}^T$ and server quantity $\mathcal{M}={[M\left(p_{s_1}\right),\dots ,M\left(p_{s_m}\right)]}^T$; while$k\le Ge$ do     for $j=1,\dots ,{\mathcal{N}}_p$ do         Transform $\langle N,{\mathit{M}}_{{\mathit{Chm}}_j^k}\rangle$ into $\langle \widehat{N},{\widehat{\mathit{M}}}_{{\mathit{Chm}}_j^k}\rangle$ according to Algorithm 1;         Solve MILPP (16) for $\langle \widehat{N},{\widehat{\mathit{M}}}_{{\mathit{Chm}}_j^k}\rangle$;         Calculate $fitness\left({\mathit{Chm}}_j^k\right)$ according to Equation (17);     end for     Let $j^{*}=arg\underset{{\mathit{Chm}}_j^k\in {\mathcal{N}}_k}{max}fitness\left({\mathit{Chm}}_j^k\right)$;     Let $\mathcal{M}:={\mathit{M}}_{Ch{m}_{j^{*}}^k}$ be the server quantity and $\mathit{Z}:=({\mathit{Z}}_1,\dots ,{\mathit{Z}}_m)$ be the server type selection corresponding to chromosome ${\mathit{Chm}}_{j^{*}}^k$;     if $k+1\le Ge$ then         $k:=k+1$;         Execute selection, crossover, and mutation to generate an offspring generation ${\mathcal{N}}_k=\{{\mathit{Chm}}_1^k,$$\dots ,{\mathit{Chm}}_{{\mathcal{N}}_p}^k\}$;     else         Output $\mathcal{M}$ and $\mathit{Z}$     end if end while

5. Illustrative Examples

In this section, the developed approach in Section 4 is illustrated by investigating the TWMG model discussed in Example 1 and a real flexible manufacturing system. The algorithms are implemented by MATLAB 2017 with YALMIP R20181012 subroutines on a computer installed Windows 10 operating system with CPU Intel Core i5 at 3.0 GHz and RAM 8 GB.

5.1. First Example

Example 3. 

Let us continue Example 1 and assume that the upper bound on the cost of servers is $R=100$. Parameters in the developed approach are set as the population size ${\mathcal{N}}_p=10$, the crossover probability ${\mathcal{P}}_c=0.7$, and the mutation probability ${\mathcal{P}}_m=0.1$.

In

Table 2. Simulation results of Example 3.

	Approaches	Genetic MILP				Genetic
Obtained Results
Maximal number of generation $Ge$		1	2	5	15	1	2	5	15
Best solution		3.0	3.0	3.0	3.0	3.3	3.3	3.3	3.1
Worst solution		4.5	4.0	3.0	3.0	6.0	5.0	5.0	4.0
Average solution		3.7	3.2	3.0	3.0	4.4	4.2	3.7	3.7
Average CPU time [s]		7.5	11.0	20.5	59.4	3.1	4.6	9.1	24.2

, we show the best solution (i.e., the minimal cycle time), the worst solution (i.e., the maximal cycle time), the average solution, and the average CPU time for the developed approach (i.e., genetic MILP) by testing a different maximum number of generations $Ge$. For each generation, we executed the developed approach ten times. An optimal/suboptimal solution is found as follows:

$$\begin{array}{c}\mathcal{M}={[2,14]}^T,{\mathit{Z}}_1={[0,0,1]}^T,{\mathit{Z}}_2={[1,0]}^T,\hfill \end{array}$$

which means that the optimal quantity of server of $t_1$ and $t_2$ are 2 and 14, respectively, while the third type of server of $t_1$ and the first type of server of $t_2$ are selected. By enumerating all possible server-type selections and server quantities, we found that the solutions obtained by the proposed approach are optimal. In addition, we also implemented the developed approach without MILP (i.e., genetic in Table 2), which means that both quantities and types of servers are generated by the genetic algorithm. It can be observed that the qualities of the solutions are improved by using the MILP we developed.

5.2. Application to a Real Flexible Manufacturing System

In this subsection, we apply the developed approach to a hydraulic torque converter production line that is taken from [36]. The hydraulic torque converter is assembled with four different products as shown in

Table 3. Production process of the flexible manufacturing system.

Pump wheel	${\mathcal{MA}}_1$→${\mathcal{MA}}_2$→${\mathcal{MA}}_3$→${\mathcal{MA}}_4$→${\mathcal{MA}}_5$→${\mathcal{MA}}_6$
Turbine	${\mathcal{MA}}_1$→${\mathcal{MA}}_7$→${\mathcal{MA}}_3$→${\mathcal{MA}}_8$→${\mathcal{MA}}_{10}$→${\mathcal{MA}}_{11}$→${\mathcal{MA}}_{12}$
	${\mathcal{MA}}_3$→${\mathcal{MA}}_9$→${\mathcal{MA}}_6$→${\mathcal{MA}}_{10}$→${\mathcal{MA}}_{11}$→${\mathcal{MA}}_{12}$
Guide wheel	${\mathcal{MA}}_1$→${\mathcal{MA}}_4$→${\mathcal{MA}}_{13}$
Cover wheel	${\mathcal{MA}}_{14}$→${\mathcal{MA}}_4$→${\mathcal{MA}}_{15}$→${\mathcal{MA}}_6$
Hydraulic torque converter	${\mathcal{MA}}_{16}$→${\mathcal{MA}}_{17}$

. The production process of these products include 25 operations operated on 17 different machines (denoted by ${\mathcal{MA}}_1,\dots ,{\mathcal{MA}}_{17}$). We mention that the turbine is also assembled by two different products. Note that some machines are shared by one or more production lines, such as ${\mathcal{MA}}_1$, ${\mathcal{MA}}_3$, ${\mathcal{MA}}_4$, and ${\mathcal{MA}}_6$.

The TWMG model is shown in Figure 4, which has 25 transitions and 54 places. It is composed of three different types of elementary circuits, i.e., process circuits that represent the manufacturing process, server circuits that represent the usage of machines, and mixed circuits that consist of both process circuits and server circuits. Tokens in places $p_1$, $p_8$, $p_{13}$, $p_{20}$, and $p_{24}$ represent the raw materials for each production line that are assumed to be 1000, i.e., $M\left(p_j\right)=1000$ ($j=1,8,13,20,24$).

In

Table 4. Unit costs of the servers and the firing delays of each operation.

Transition	Machine	Server Type	Unit Cost of Server	Firing Delay	Transition	Machine	Server Type	Unit Cost of Server	Firing Delay
${\mathit{t}}_{\mathit{i}}$	$\mathcal{MA}$	j	$\mathit{\lambda }({\mathit{t}}_{\mathit{i}},\mathit{j})$	$\mathit{\delta }({\mathit{t}}_{\mathit{i}},\mathit{j})$ [s]	${\mathit{t}}_{\mathit{i}}$	$\mathcal{MA}$	j	$\mathit{\lambda }({\mathit{t}}_{\mathit{i}},\mathit{j})$	$\mathit{\delta }({\mathit{t}}_{\mathit{i}},\mathit{j})$ [s]
$t_1$	${\mathcal{MA}}_1$	1	7	27	$t_{13}$	${\mathcal{MA}}_6$	2	7	34
		2	15	19			3	8	29
		3	20	15			4	10	26
		4	23	13			5	11	20
$t_2$	${\mathcal{MA}}_2$	1	4	25	$t_{14}$	${\mathcal{MA}}_{10}$	1	10	45
		2	8	22			2	14	38
$t_3$	${\mathcal{MA}}_3$	1	7	40	$t_{15}$	${\mathcal{MA}}_{11}$	1	8	17
		2	8	37			2	12	13
		3	9	25	$t_{16}$	${\mathcal{MA}}_{12}$	1	5	18
$t_4$	${\mathcal{MA}}_4$	1	8	16			2	9	12
		2	9	15	$t_{17}$	${\mathcal{MA}}_1$	1	9	15
		3	10	9			2	15	14
		4	12	6			3	20	10
$t_5$	${\mathcal{MA}}_5$	1	3	29			4	23	6
		2	6	25	$t_{18}$	${\mathcal{MA}}_4$	1	8	18
		3	8	20			2	9	16
$t_6$	${\mathcal{MA}}_6$	1	6	38			3	10	16
		2	7	35			4	12	13
		3	8	32	$t_{19}$	${\mathcal{MA}}_{13}$	1	13	24
		4	10	28			2	17	19
		5	11	25			3	20	13
$t_7$	${\mathcal{MA}}_1$	1	9	26	$t_{20}$	${\mathcal{MA}}_{14}$	1	7	38
		2	15	23			2	11	31
		3	20	18	$t_{21}$	${\mathcal{MA}}_4$	1	8	25
		4	23	12			2	9	22
$t_8$	${\mathcal{MA}}_7$	1	2	31			3	10	20
		2	5	26			4	12	14
		3	7	20	$t_{22}$	${\mathcal{MA}}_{15}$	1	10	36
$t_9$	${\mathcal{MA}}_3$	1	7	33			2	14	30
		2	8	25	$t_{23}$	${\mathcal{MA}}_6$	1	6	37
		3	9	16			2	7	32
$t_{10}$	${\mathcal{MA}}_8$	1	2	11			3	8	29
		2	7	8			4	10	24
$t_{11}$	${\mathcal{MA}}_3$	1	7	26			5	11	20
		2	8	22	$t_{24}$	${\mathcal{MA}}_{16}$	1	14	58
		3	9	10			2	21	42
$t_{12}$	${\mathcal{MA}}_9$	1	5	47			3	30	20
		2	8	42	$t_{25}$	${\mathcal{MA}}_{17}$	1	7	13
		3	13	35			2	8	10
$t_{13}$	${\mathcal{MA}}_6$	1	6	35			3	12	6

, we present the unit costs of servers and the firing delays of the corresponding transitions. The budget is set to $R=300$. Simulation results for different cases are presented in

Table 5. Simulation results of the developed approach for the flexible manufacturing system.

	Approaches	Genetic MILP				Genetic
Obtained Results
Maximal number of generation $Ge$		1	2	5	10	2	5	10	40	70	100
Best solution		76.0	72	68.0	68.0	130.0	102.0	102.0	90.0	90.0	90.0
Worst solution		84.0	77.3	76.0	76.0	212.0	204.0	180.0	168.0	130.0	130.0
Average solution		79.7	75.2	71.3	70.6	171.8	159.4	152.2	126.2	120.8	111.7
Average CPU time [s]		72.9	152.9	396.5	1059.3	4.7	12.7	28.8	142.8	433.3	843.8

. Parameters in the developed approach are the same as in Example 3.

For all of the cases, we execute each approach ten times. Since the best solution for the maximum number of generations $Ge=5$ is identical to the solution obtained for generation $Ge=10$, there is no need to test more generations for the genetic MILP approach. An optimal/suboptimal solution is found by the developed approach with the cycle time $\chi \left(G\right)=68$, and the server-type selection and server quantity are as follows:

$$\begin{array}{c}\mathcal{M}={[1,1,1,2,1,1,2,1,2,1,1,2,1,2,1,1,1,1,1,1,1,1,0,1,1]}^T,\hfill \\ Z_1\left(1\right)=1,Z_2\left(1\right)=1,Z_3\left(3\right)=1,Z_4\left(1\right)=1,Z_5\left(1\right)=1,\hfill \\ Z_6\left(5\right)=1,Z_7\left(1\right)=1,Z_8\left(1\right)=1,Z_9\left(3\right)=1,Z_{10}\left(1\right)=1,\hfill \\ Z_{11}\left(3\right)=1,Z_{12}\left(1\right)=1,Z_{13}\left(5\right)=1,Z_{14}\left(1\right)=1,Z_{15}\left(1\right)=1,\hfill \\ Z_{16}\left(2\right)=1,Z_{17}\left(1\right)=1,Z_{18}\left(1\right)=1,Z_{19}\left(1\right)=1,Z_{20}\left(2\right)=1,\hfill \\ Z_{21}\left(1\right)=1,Z_{22}\left(1\right)=1,Z_{23}\left(5\right)=1,Z_{24}\left(3\right)=1,Z_{25}\left(1\right)=1.\hfill \end{array}$$

Note that due to the shared usage of resources, some different operations (transitions) are executed by the same machine ${\mathcal{MA}}_i$ ($i=1,3,4,6$). Therefore, the server quantities of machine ${\mathcal{MA}}_i$ equals the sum of the server quantities of all the transitions corresponding to ${\mathcal{MA}}_i$; the server types of all the transitions corresponding to ${\mathcal{MA}}_i$ should be identical.

$$\begin{array}{c}\mathrm{Server}\mathrm{quantity}\mathrm{of}{\mathcal{MA}}_1:M\left(p_{s_1}\right)+M\left(p_{s_7}\right)+M\left(p_{s_{17}}\right)=4,\hfill \\ \mathrm{Server}\mathrm{quantity}\mathrm{of}{\mathcal{MA}}_3:M\left(p_{s_3}\right)+M\left(p_{s_9}\right)+M\left(p_{s_{11}}\right)=4,\hfill \\ \mathrm{Server}\mathrm{quantity}\mathrm{of}{\mathcal{MA}}_4:M\left(p_{s_4}\right)+M\left(p_{s_{18}}\right)+M\left(p_{s_{21}}\right)=4,\hfill \\ \mathrm{Server}\mathrm{quantity}\mathrm{of}{\mathcal{MA}}_6:M\left(p_{s_6}\right)+M\left(p_{s_{13}}\right)+M\left(p_{s_{23}}\right)=2.\hfill \end{array}$$

From the simulation results, we can conclude that in the case of the same maximum number of generations, the cycle time (i.e., the objective function) obtained by the genetic MILP approach is smaller than that of the Genetic approach, i.e., the solution obtained by the genetic approach is improved by using the MILP.

We conclude this section by discussing the previous works. The approaches developed in [33,34,35,36] can provide optimal or near-optimal solutions under the condition that the types of resources are given. In this paper, we further extend these works by assuming that the types of resources are variables that also have to be optimized. Therefore, the existing approaches in [33,34,35,36] cannot provide a solution for the problem considered in this paper.

6. Conclusions

In this paper, we study the performance optimization for a class of PNs to maximize the throughput of the system subject to a given budget, while both quantities and typesof servers are decision variables. A genetic algorithm combined with mixed-integer linear programming was originally developed to obtain a near-optimal solution. The developed approach is based on linear programming techniques and provides an efficient solution for solving the performance optimization problem where both quantities and types of resources are simultaneously optimized. Our future work will focus on exploring an analytical solution for the considered optimization problem. On the other hand, we will consider improving the efficiency of the developed approach by using some advanced hybrid methods [44].