Petri Net Model Predictive Control Method for Batch Chemical Systems

Abstract

In order to address the problem of the real-time scheduling and control of batch chemical systems, this work proposes a model predictive control method based on Petri nets. First, a method is presented to construct a batch chemical system’s timed Petri net model. Second, a control structure is designed to augment the Petri net model to control the valves. This results in timed Petri nets that formally represent the process specifications of a batch chemical system. Third, a model predictive control method is developed to schedule and control timed Petri nets, where a proposed heuristic function is utilized to perform the optimization computation. The model parameters are dynamically adjusted using online data, and both scheduling and valve control instructions are calculated in real time. Finally, a series of experiments is carried out in a beer canning plant to verify the proposed method. According to the experimental results, the scheduling and control problem can be solved in real time, where the online computations can be performed in milliseconds, and the resulting scheduling strategies are optimal or near-optimal.

1. Introduction

Under the influence of the Internet of Things and intelligent manufacturing technologies, the resource units and task numbers in batch chemical systems are increasing. The logical relationships among processes in competition for resource units are becoming increasingly complex, leading to a combinatorial explosion of system states. Simultaneously, the system must deal with unforeseen events such as urgent orders, process adjustments, and equipment failures. This necessitates rapid real-time solutions for scheduling strategies and control commands, posing highly complex scheduling and control problems.

Batch chemical systems are driven by events such as the opening or closing of valves and the initiation and completion of operations, making them a typical group of discrete event systems. Petri nets are an excellent tool for discrete event systems [1,2] and are widely used in research on fault diagnosis, supervisory control, and optimization scheduling [3,4].

Batch chemical systems involve complex scheduling strategies and specific valve control commands translated from scheduling strategies [5,6,7,8,9,10,11,12,13,14]. Since scheduling and control commands require real-time computation and execution, responding quickly to unforeseen events, such as emergency orders and equipment failures, becomes challenging.

Regarding real-time scheduling, modeling via Petri nets and the use of model predictive control (MPC) are possible [15,16,17]. However, they fail to address the mismatch between the system model and the physical plant, and the repeated expansion of the reachability tree leads to unnecessary computation.

To overcome these drawbacks, this work presents an MPC method using place-timed Petri nets, which not only addresses the mismatch between the Petri net model and the actual plant but also fulfills the real-time scheduling requirement. It is summarized as follows.

(1)

For batch chemical systems, a systematic method is proposed to obtain its place-timed Petri net model by analyzing the relationship between the process specifications and logical operations.

(2)

A heuristic function is designed based on the place-timed Petri net mode to estimate states’ time costs, which can be used to smartly adjust the searching direction within a reachability graph to reduce the computation required.

(3)

A predictive control algorithm is designed to search for an optimal or near-optimal control action (transition) under the guidance of a heuristic function within each prediction time domain (time step). It has a model correction module that collects data online about operational times and device failures, and we can dynamically modify the Petri net model accordingly.

(4)

We conduct experiments on a beer canning plant. The online computations of control actions are completed within milliseconds, and the makespan is close to the optimal one. The results show that the proposed method provides an efficient and practical solution for the real-time scheduling of a batch chemical plant.

Compared to the approaches in [15,16,17], our approach addresses the issue of the mismatch between the Petri net model and the actual plant. The model calibration is performed in real-time according to abrupt events, such as rush orders and device failures. Furthermore, we retain a portion of the reachability graph of the previous time step, and the expanded part of the graph is saved in each predictive time domain. This enables us to explore more states and thereby enhance the scheduling performance.

The rest of this paper consists of the following sections. Section 1 presents some related works and describes contributions concerning the existing methods. Section 2 reviews basic definitions and notions regarding Petri nets and MPC. Section 3 describes the optimization issue of batch chemical systems. Section 4 proposes the method to model batch chemical systems using place-timed Petri nets. Section 5 presents an MPC method to schedule a batch chemical system based on Petri nets and the proposed heuristic function. Section 6 describes a series of experiments to verify the proposed method. Section 7 provides the conclusions of the work.

2. Related Works

The control and scheduling problems of batch chemical systems have received widespread attention, leading to valuable research efforts. Tittus and Lennartson et al. [5] propose a hierarchical Petri net control method for batch chemical systems that can prevent deadlock states, allocate material transport equipment and reactors reasonably, and execute multiple process flows in parallel. Wang et al. [6,7] introduce a control approach based on hierarchical Petri nets for batch chemical systems, capable of generating control instructions for the production and transportation of multiple materials, thereby increasing the system’s stability. Susumu et al. [8] develop a Petri net model for a batch chemical production process and propose a method to design reliable operation instructions. Falkman et al. [9] introduce a process algebra Petri net, which is helpful in accurately describing the complex request relationships between operations and resources. Ghaeli et al. [10] establish a place-timed Petri net model for batch factories and present a branching and bounding algorithm to compute optimal scheduling strategies. Lai et al. [11] model a pipeline network of a batch chemical plant as a Petri net and use integer programming to determine the shortest material transfer paths. With max-plus algebra, Weyerman et al. [12] construct a scheduling optimization model of batch flow shops to find optimal processing sequences. Given a batch chemical system, Lin et al. [13] design a Petri-net-based A* algorithm to obtain the optimal paths within a reachable graph and map the paths to valve operational instructions. Given a place-timed Petri net, Zhou et al. [14] propose a state space approximation method to reduce the computational complexity in searching for optimal or suboptimal scheduling strategies. These works show promising progress in scheduling batch chemical systems. However, they fail to compute scheduling strategies real time.

Model predictive control (MPC) is an important type of advanced control approach that can utilize system information through well-developed models and real-time process measurements to predict the future trajectories of processes. Cahyono et al. [18] propose a model predictive allocation method that integrates berth and dockside crane models to enhance the efficiency during the berthing process. However, in the rolling optimization part, an exhaustive search algorithm is employed, resulting in time-consuming computation. Lefebvre et al. [15] introduce a Petri-net-based model predictive control method that can be used to calculate the shortest or approximate shortest transition firing sequences to reach target states. Lefebvre et al. [16,17] extend the method in [15] to a timed Petri net such that approximate shortest-duration scheduling strategies can be calculated even if there exist uncontrollable transitions. These works have achieved good results in real-time scheduling using MPC. However, they do not consider abrupt events, which may cause the MPC methods to fail.

3. Preliminaries

An ordinary Petri net is $N=(P,T,F,W)$, where P is a finite non-empty set of places and T is a finite non-empty set of transitions, where $P\cup T\ne \varnothing \wedge P\cap T=\varnothing$. $F\subseteq (P\times T)\cup (T\times P)$ is the set of directed arcs connecting the nodes, i.e., the directed arcs from the place to the transition or from the transition to the place. $W:F\to N^{+}$ denotes the weights mapped to the directed arcs. $\left[N\right]$ denotes the $\left|P\right|\times \left|T\right|$ integer matrix such that

$$\left[N\right](p,t)=\left\{\begin{array}{cc}W(t,p),\hfill & \mathrm{if}(t,p)\in F\wedge (p,t)\notin F\hfill \\ -W(p,pt),\hfill & \mathrm{if}(t,p)\notin F\wedge (p,t)\in F\hfill \\ W(t,p)-W(p,t),\hfill & \mathrm{if}(t,p)\in F\wedge (p,t)\in F\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(1)

Given that $x\in P\cup T$ is a node in a Petri net, define the x forward set as ${ }^{•}x=\{y\in P\cup T|(y,x)\in F\}$; define the x backward set as $x^{•}=\{y\in P\cup T|(x,y)\in F\}$. This representation can be extended to a set of nodes, i.e., given that $X\subseteq P\cup T$, ${ }^{•}X={\cup }_{x\in X}{ }^{•}x$ and $X{ }^{•}={\cup }_{x\in X}{x}^{•}$.

A marking m is a vector indicating a distribution of tokens among places. Given a Petri net, a transition t is state-enabled at m, if $m\left(p\right)\ge W(p,t)\wedge \forall p\in { }^{•}t$, i.e., $m[t\rangle$. If transition t can fire, the net reaches a new marking $m^{\prime }$ such that

$$\forall p\in P,m^{\prime }\left(p\right)=m\left(p\right)+\left[N\right](p,t),$$

(2)

and this is denoted as $m[t\rangle m^{\prime }$. If there exists a transition sequence ${\sigma }_{=}{e}_1{e}_2...e_n$ and marking $m_1,m2,\cdots ,m_n$ such that $m_0[e_1\rangle m_1[e_2\rangle m_2\cdots m_{n_1}[e_n\rangle m_n$ holds, then the marking $m_m$ is reachable from marking $m_0$, denoted as $m_0[\sigma \rangle m_n$.

A place-timed Petri net (P-TPN) is defined as $G_t=(N,m_0,d)$, where N is an ordinary Petri net structure, $m_0$ is the initial marking, and $d:P\to \left\{0\right\}\cup R^{+}$ is the function mapping the set of places to the set $R^{+}$ of non-negative real numbers, where $d\left(p\right)$ denotes the delay of the place. A place-timed Petri net is used for system modeling, and the delay of the place corresponding to a time-consuming task is not zero. In this paper, the number of tokens in the place is not greater than one.

The state of a place-timed Petri net is $X=(m,w,g)$, where m is the marking of state X, g is the cost function of the system, and $w:P^{\prime }\to \left\{0\right\}\cup R^{+}$ is a function in which the set $P^{\prime }$ of places has a token for the set $R^{+}$, specifying the waiting time of the token in the place. If there exists a transition sequence $\sigma$ such that $m_0[\sigma \rangle m_n$, where $m_0$ and $m_n$ are the markings of $X_0$ and $X_n$, respectively, then the state $X_n$ is reachable from marking $X_0$, denoted as $X_0[\sigma \rangle X_n$.

Given the state $X_K=(m_k,w_k,g_k)$ of a place-timed Petri net at the k-th moment, if the transition $e_k$ is enabled, we update the marking $m_{k+1}$, the waiting time $w_{k+1}$, and the cost time $g_{k+1}$ according to Equations (2)–(4).

$$\forall p\in P,w_{k+1}=\left\{\begin{array}{cc}min(w_{k+1}+max(d\left(p\right),w_k),d\left(p\right)),\hfill & \mathrm{if}{m}_{k+1}\left(p\right)\ne 0\wedge p\notin e_k^{•}\hfill \\ 0,\hfill & \mathrm{if}{m}_{k+1}\left(p\right)=0\vee p\in e_k^{•}\hfill \end{array}\right.$$

(3)

$$g_{k+1}=g_k+{\lambda }_{k+1},$$

(4)

where ${\lambda }_{k+1}$ is the time interval between $X_k$ and $X_{k+1}$, i.e., ${\lambda }_{k+1}\ge max(d\left(p\right)-w_k\left(p\right))$.

Dijkstra and $A^{*}$ algorithms are frequently used as tree and graph searching methods to obtain an optimal solution. The former selects the node with the smallest cost to explore a state graph and can guarantee that its solution is an optimal path. The latter utilizes the sum of the cost and heuristic function to adjust the searching direction and outperforms the former in terms of computational efficiency if its heuristic function is appropriate.

Model predictive control (MPC) is an optimal control method that uses a dynamic model to predict future behavior and solves for the optimal control action at each time step to satisfy constraints and performance metrics [19]. It is commonly used in various dynamic systems, including industrial process control, robot control, etc. MPC dynamically adjusts the control strategy through real-time sensor feedback to match the system behavior more accurately and achieve stability and performance optimization.

4. Problem Description

A batch chemical system carries out a series of operations, each requiring a certain amount of time and a set of resources, such as valves, storage tanks, and filters. Additionally, it may encounter unexpected events such as process adjustments, urgent orders, and equipment failures. Therefore, control instructions for valves need to be calculated in real time to adjust the order of operations, ensuring the system’s productive efficiency.

To describe a batch chemical system, let D represent the set of resources and O the set of all production operations. Specifically, D has two subsets V and U. Set $V=\{v_1,\dots ,v_i\}$ is the set of valves, where each valve $v_i$ has two states, i.e., the open state $v_{{\mathrm{s}}_i}$ and the closed state ${\overline{v}}_{{\mathrm{s}}_i}$. Set $U=\{u_1,\dots ,u_j,f_1,\dots ,f_z\}$ is the set of tanks and filters, where $j,z\in N^{+}$. $u_1,\dots ,u_j$ are buffer tanks, and $f_1,\dots ,f_z$ are filters. Note that, for each tank or filter, ${\overline{u}}_{s_j}\left({\overline{f}}_{s_z}\right)$, i.e., the tank is full, and the filter is used. Therefore, the set of resource states is denoted as $D_s=\{v_{{\mathrm{s}}_1},...,v_{{\mathrm{s}}_i},{\overline{v}}_{{\mathrm{s}}_1},...,{\overline{v}}_{{\mathrm{s}}_i},u_{s_1},...,u_{s_j},{\overline{u}}_{s_1},...,{\overline{u}}_{s_j},f_{s_1},...,f_{s_z},{\overline{f}}_{s_1},...,{\overline{f}}_{s_z}\}$. For an operation $o\in O$, its required set of resource states is represented as $r\left(o\right)\subseteq D_s$, and $\delta \left(o\right):o\to N^{+}$ is the execution time of o.

As shown in Figure 1, a beer canning plant [20] is considered. The plant performs four tasks: filling, filtering, bottling, and cleaning. $u_s$ is the tank for raw beer; $u_1$ and $u_2$ are two buffer tanks. $f_1$, $f_2$, and $f_3$ are three filters. $CIP$ stands for the supply and recovery module for cleaning agents, while the bottling module is responsible for canning. $v_1,\dots ,v_{20}$ are double piston valves. Each one can be switched to either an “open“ or “closed“ position. When a valve is open, beer flows through the horizontal pipeline under its control. When a valve is closed, beer flows through the vertical pipeline under its control. There are 12 operations, denoted by $o_1,\dots ,o_{12}$, as summarized in

Table 1. Operations of the beer canning plant.

Operations	Open Valve States	Closed Valve States	Tank or Filter States	Time
$o_1$	$v_{s_2},v_{s_3}$	${\overline{v}}_{s_1},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_{12}}$	$u_{s_1}$	5 s
$o_2$	$v_{s_{12}},v_{s_{13}}$	${\overline{v}}_{s_3},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_{11}}$	$u_{s_1}$	6 s
$o_3$	$v_{s_3},v_{s_4}$	${\overline{v}}_{s_1},{\overline{v}}_{s_2},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}}$	${\overline{u}}_{s_1},u_{s_2},f_{s_1}$	11 s
$o_4$	$v_{s_{13}},v_{s_{14}}$	${\overline{v}}_{s_3},{\overline{v}}_{s_4},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{12}}$	${\overline{u}}_{s_1},u_{s_2},f_{s_2}$	12 s
$o_5$	$v_{s_{18}},v_{s_{19}}$	${\overline{v}}_{s_3},{\overline{v}}_{s_4},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{17}}$	${\overline{u}}_{s_1},u_{s_2},f_{s_3}$	13 s
$o_6$	$v_{s_4},v_{s_5}$	${\overline{v}}_{s_1},{\overline{v}}_{s_6},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}}$	${\overline{u}}_{s_2}$	7 s
$o_7$	$v_{s_{14}},v_{s_{15}}$	${\overline{v}}_{s_5},{\overline{v}}_{s_4},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{16}}$	${\overline{u}}_{s_2}$	8 s
$o_8$	$v_{s_8},v_{s_9}$	${\overline{v}}_{s_3},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{18}}$	$u_{s_1}$	2 min
$o_9$	$v_{s_7},v_{s_{10}}$	${\overline{v}}_{s_4},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{19}}$	$u_{s_2}$	2 min
$o_{10}$	$v_{s_1},v_{s_6}$	${\overline{v}}_{s_2},{\overline{v}}_{s_3},{\overline{v}}_{s_4},{\overline{v}}_{s_5},{\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{17}}$	${\overline{f}}_{s_1}$	2 min
$o_{11}$	$v_{s_{11}},v_{s_{16}}$	${\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{12}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{15}},{\overline{v}}_{s_{17}}$	${\overline{f}}_{s_2}$	2 min
$o_{12}$	$v_{s_{17}},v_{s_{20}}$	${\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{18}},{\overline{v}}_{s_{19}}$	${\overline{f}}_{s_3}$	2 min

.

A filling operation seeks to transport raw beer from $u_s$ through the pipeline to the buffer tank $u_1$. There are two types of filling operations, $o_1$ and $o_2$. Operation $o_1$ requires the opening of valves $v_2$ and $v_3$; the closing of valves ${\overline{v}}_1$, ${\overline{v}}_8$, ${\overline{v}}_9$, and ${\overline{v}}_{12}$; and an execution time of five seconds. The set of resource states required by $o_1$ is $r\left(o_1\right)=\{v_{s_2},v_{s_3},{\overline{v}}_{s_1},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_{12}},u_{s_1}\}$, and the execution time of $o_2$ is $\delta \left(o_2\right)=6$ s.

A filtering operation serves to transfer liquid from buffer tank $u_1$, through filters ($f_1,f_2,f_3$), to buffer tank $u_2$. There are three types of filtering operations, $o_3$, $o_4$, and $o_5$. Operation $o_3$ requires the opening of valves $v_3$ and $v_4$; the closing of valves ${\overline{v}}_{s_1},{\overline{v}}_{s_2},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_7}$, and ${\overline{v}}_{s_{10}}$; and the execution time 11 s. Hence, $r\left(o_3\right)=\{v_{s_3},v_{s_4},{\overline{v}}_{s_1},{\overline{v}}_{s_2},{\overline{v}}_{s_8},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{u}}_{s_1},u_{s_2},f_{s_1}\}$, and $\delta \left(o_3\right)=11$ s. Similarly, $r\left(o_4\right)=$$\{v_{s_{13}},$$v_{s_{14}},$${\overline{v}}_{s_3},$${\overline{v}}_{s_4}$$,{\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{12}},{\overline{u}}_{s_1},u_{s_2},f_{s_2}\}$, $\delta \left(o_4\right)=12$ s, $r\left(o_5\right)=$$\{v_{s_{18}},v_{s_{19}},$${\overline{v}}_{s_3},{\overline{v}}_{s_4},{\overline{v}}_{s_7},$${\overline{v}}_{s_8},{\overline{v}}_{s_9},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{17}},{\overline{u}}_{s_1},u_{s_2},f_{s_3}\}$, and $\delta \left(o_5\right)=13$ s.

A bottling operation transfers liquid from buffer tank $u_2$ to the bottling module for beer bottling. There are two types of bottling operations, $o_6$ and $o_7$. In detail, $r\left(o_6\right)=\{v_{s_4},v_{s_5},{\overline{v}}_{s_1},{\overline{v}}_{s_6},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{u}}_{s_2}\}$, $\delta \left(o_6\right)=7$ s, $r\left(o_7\right)=\{v_{s_{14}},v_{s_{15}},{\overline{v}}_{s_5},{\overline{v}}_{s_4},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{16}},{\overline{u}}_{s_2}\}$, and $\delta \left(o_7\right)=8$ s.

A cleaning operation cleans the resources in U, and there are five cleaning operations:

(1)

Operation $o_8$ (cleaning buffer tank $u_1$): It is required that the cleaning liquid flows from $CIP$ into buffer tank $u_1$ for 120 s. The set of required resources is $r\left(o_8\right)$$=\{v_{s_8},$$v_{s_9},$${\overline{v}}_{s_3},{\overline{v}}_{s_7},{\overline{v}}_{s_7},{\overline{v}}_{s_{10}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{18}},u_{s_1}\}$, and the cleaning time is $\delta \left(o_8\right)=120$ s. The buffer tank $u_1$ must be cleaned after every two uses.

(2)

Operation $o_9$ (cleaning buffer tank $u_2$): It is required that the cleaning liquid flows from $CIP$ into buffer tank $u_2$ for 120 s. The set of required resources is $r\left(o_9\right)=\{v_{s_7},v_{s_{10}},{\overline{v}}_{s_4},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{19}},{\overline{u}}_{s_2}\}$, and the cleaning time is $\delta \left(o_9\right)=120$ s. The buffer tank $u_2$ must be cleaned after every two uses.

(3)

Operation $o_{10}$ (cleaning filter $f_1$): It is required that the cleaning liquid flows from $CIP$ into filter $f_1$ for 120 s. The set of required resources is $r\left(o_{10}\right)=\{v_{s_1},v_{s_6},{\overline{v}}_{s_2},{\overline{v}}_{s_3},{\overline{v}}_{s_4},{\overline{v}}_{s_5},{\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{11}},{\overline{v}}_{s_{17}},{\overline{f}}_{s_1}\}$, and the cleaning time is $\delta \left(o_{10}\right)=120$ s. The filter $f_1$ must be cleaned after every use.

(4)

Operation $o_{11}$ (cleaning filter $f_2$): It is required that the cleaning liquid flows from $CIP$ into filter $f_2$ for 120 s. The set of required resources is $r\left(o_{11}\right)=\{v_{s_{11}},v_{s_{16}},{\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{12}},{\overline{v}}_{s_{13}},{\overline{v}}_{s_{14}},{\overline{v}}_{s_{15}},{\overline{v}}_{s_{17}},{\overline{f}}_{s_2}\}$, and the cleaning time is $\delta \left(o_{11}\right)=120$ s. The filter $f_2$ must be cleaned after every two uses.

(5)

Operation $o_{12}$ (cleaning filter $f_3$): It is required that the cleaning liquid flows from $CIP$ into filter $f_3$ for 120 s. The set of required resources is $r\left(o_{12}\right)=\{v_{s_{17}},v_{s_{20}},{\overline{v}}_{s_7},{\overline{v}}_{s_8},{\overline{v}}_{s_{18}},{\overline{v}}_{s_{19}},{\overline{f}}_{s_3}\}$, and the cleaning time is $\delta \left(o_{12}\right)=120$ s. The filter $f_3$ must be cleaned after every three uses.

Evidently, an operation cannot be performed simultaneously with another one once there are resource conflicts. For example, $o_1$ and $o_2$ cannot be simultaneously performed since $o_1$ requires the opening of $v_3$ while operation $o_2$ requires the closing of $v_3$. However, some operations can run in parallel. For instance, $o_1$ and $o_6$ can be simultaneously executed since they are not in conflict. Therefore, there are both sequential and parallel relations between operations, and different sequences of executed operations may lead to different makespans. In addition, when scheduling a plant, unexpected events need to be considered. For example, an urgent order may suddenly arrive when the plant is running at a given schedule, the duration of an operation may change due to worn devices, or a filter or tank device may be suddenly damaged. Thus, it is essential to quickly modify the original schedule and to respond promptly to abrupt events. The key lies in quickly determining the scheduling strategies and controlling the commands to minimize the processing time.

5. Petri Net Model of a Batch Chemical System

In order to develop a model predictive control method, we need to model a given batch chemical system as a place-timed Petri net. To this end, several notations are introduced.

Definition 1. 

A logical operation ρ is a binary tuple $(\gamma ,k)$ that satisfies

$$\sum _{o\in O_{\rho }}\gamma \left(o\right)=k,$$

(5)

where $O_{\rho }$ is the set of productive operations, $\gamma \left(o\right)$ represents the number of times to execute o, and k is a non-negative integer.

In a real-life plant, a logical operation means a specific working procedure on a part. As shown in Figure 1, a filling operation can be realized by $o_1$ or $o_2$, and, consequently, it can be represented as the logical operation ${\rho }_1=({\gamma }_1,1)$ satisfying ${\displaystyle \sum _{o\in O_{\rho }}}{\gamma }_1\left(o\right)=1$, i.e., ${\gamma }_1\left(o_1\right)+{\gamma }_1\left(o_2\right)=1$.

Given a batch chemical system J, the batch size, i.e., the number of times to execute the system J, is denoted by $\mathrm{\Omega }\left(J\right)$.

Definition 2. 

An ordered pair of logical operations $({\rho }_i,{\rho }_j)$ is called a process relation, ${\rho }_i$ is a pre-operation of ${\rho }_j$, and ${\rho }_j$ is a post-operation of ${\rho }_i$.

As shown in Figure 1, ${\rho }_1$ is the logical operation of the filling operation, ${\rho }_2$ is the logical operation of the filtering operation, and the processing flow is filling and then filtering, so ${\rho }_1$ is a pre-operation of ${\rho }_2$ and ${\rho }_2$ is a post-operation of ${\rho }_1$.

Definition 3. 

Operations o and $o^{\prime }$ are in conflict if o requires a valve to open and $o^{\prime }$ requires a valve to be closed, or they require different states of the same device, such as a tank or filter, i.e., $[\exists v\in V,v\in r\left(o\right)\wedge \overline{v}\in r\left(o^{\prime }\right)]\vee [\exists x\in U,x\in r\left(o\right)\wedge x\in r\left(o^{\prime }\right)]$.

Definition 4. 

A set of operations is in conflict if each operation in it is in conflict with all others.

Definition 5. 

A set of operations is maximally in conflict, denoted by $O_{max}$, if it is conflict and any superset of it is not in conflict, and the set of maximally conflicting sets is represented as ${\mathbf{O}}_{\mathbf{max}}$.

Definition 6. 

A process graph is a binary tuple $(\zeta ,\psi )$, where ζ is the set of all logical operations and ψ is the set of all process relations.

Given a batch chemical system J, its place-timed Petri net model is $G_{ts}=(P^J\cup P^{\overline{J}}\cup P^O\cup P^b\cup P^m,T,F,W,d,m_0)$, where $P^J$ is the finite non-empty set of start places, $P^{\overline{J}}$ is the finite non-empty set of end places, $P^O$ is the finite non-empty set of operation places, $P^b$ is the finite non-empty set of buffer operation places, and $P^m$ is the finite non-empty set of monitor places. It can be obtained by manipulating data on the device resources, process recipes, and so on.

Furthermore, the Petri net modeling algorithm for batch chemical systems plays a crucial role in the model adjustment module of our MPC method, which can be used to reconstruct the Petri net model automatically when abrupt events occur.

For a batch chemical system, Algorithm 1 provides a modeling method to automatically generate the place-timed Petri net from a given group of data about resources such as valves, tanks and filters, batch sizes, operations, and recipes. Step 1 is to initialize the elements of the place-timed Petri net. Steps 2–14 make up a loop where the logical operation variable is the cyclic variable and, for the logical operation of process relations, they design the places, transitions, and arcs. Steps 20–26 make up the loop, where the maximally conflicting set of operations $O_{max}$ is the cyclic variable, and they design a monitor place for each $O_{max}\in {\mathbf{O}}_{\mathbf{max}}$. By means of the monitor places, the number of marked places, which represent the operations in a maximally conflicting set of operations, is, at most, one; consequently, two operations cannot be simultaneously executed if they are in conflict.

By Algorithm 1, we obtain the place-timed Petri net model of the beer canning plant, as shown in Figure 2. Here, we show the procedures to generate the Petri net. Through the production operations in Definition 1 and Table 1, we refine 15 logical operations and store them in $\zeta$. According to Definition 2, we have 12 pairs of process relations and store them in $\psi$. According to Definition 6, we group $\zeta$ and $\psi$ into the process graph $(\zeta ,\psi )$. According to Definitions 3–5 and Table 1, we obtain nine maximally conflicting sets. As a result, we obtain the inputs of Algorithm 1, which are the set of operations O, the operation time $\delta$, the set of maximally conflicting sets ${\mathbf{O}}_{\mathbf{max}}$, the process graph $(\zeta ,\psi )$, and batch size $\mathrm{\Omega }\left(J\right)$. According to Steps 1–14, the operation places, buffer places, transitions, arcs, arc weights, and initial markings of places are designed. Steps 14–17 aim to obtain the batch-head places of jobs and to design transitions connecting these batch starting places with the operation places. Similarly, Steps 17–20 aim to design the batch ending places of jobs. Finally, Steps 20–26 aim to design the monitor places for the maximally conflicting sets such that no operation competes for resources with any other operation.

Algorithm 1: Petri net modeling of a batch chemical system

6. Petri-Net-Based Predictive Control for Batch Chemical Systems

On the basis of the place-timed Petri net, a model predictive control method is presented to schedule and control a batch chemical plant in real time. It consists of three parts: the prediction model, rolling optimization, and feedback correction.

The model prediction is responsible for determining an appropriate event (transition) to be executed at each current time. This involves evaluating all candidate transitions by means of the evolving trajectories within the given prediction time domain. To do so, we need to construct a heuristic function to evaluate the execution time from any state to a goal one.

In a Petri net, an elementary path is an ordered sequence of nodes, i.e., $\pi =x_1{x}_2...x_K$, where $x_{k+1}$ is an output node of $x_k$ for $k=1,...,K-1$. The beginning and terminal nodes of $\pi$ are denoted by ${ }^{•}\pi$ and ${\pi }^{•}$, respectively. The delay cost of an elementary path $\pi$ is $\tau \left(\pi \right)={\displaystyle \sum _{p\in P_{\pi }}}d\left(p\right)$, where $P_{\pi }$ denotes the places occurring in $\pi$ and $d\left(p\right)$ is the delay of place p.

Definition 7. 

For an operation place $p\in P^o$, an elementary path is called its downstream path if ${ }^{•}\pi =p$ and ${\pi }^{•}=p_{\overline{J}}$, where $p_{\overline{J}}$ is a place representing the complete logical operation of a system, and the set of its downstream paths is denoted by ${\mathrm{\Pi }}_p$.

Since the completion of jobs is described as the flow of tokens into certain places, we can define the time cost that tokens require by means of the downstream path. Consequently, we obtain a method to evaluate a Petri net’s states and search for them within or near the transition trajectories that require minimal time.

The path cost function is defined as follows:

$$h_k\left(m_k\right)=\underset{p\in P^o}{max}(\underset{\pi \in {\mathrm{\Pi }}_p}{min}\tau \left(\pi \right)·m_k\left(p\right)),$$

(6)

where $m_k$ is the marking in a state $X_k$.

According to Equation (6), the path cost can be used to estimate the time taken to complete all jobs and, consequently, to provide an approach to the optimization problem in the proposed Petri-net-based MPC.

A place-timed Petri net plays the role of the prediction model and is used to explore a sub-reachability graph, where a current state $X_k=(m_k,w_k,g_k)$ is taken as the root node, within a given prediction time domain H, where $H\to N^{+}$. By evaluating the leaf nodes of the sub-reachability graph with $g_k\left(m_k\right)+h_k\left(m_k\right)$, the leaf node with the minimal value is chosen since it is most possible in the optimal trajectory. By backtracking the sub-reachability graph from the leaf node, we can find the transition $e_{k+1}$ that can be fired at the current state $X_k$ and consequently take it as the control action at the current state.

Sensors that detect the aging of the equipment can lead to variations in operating process times, and devices occasionally break down in practice. The mismatch between an original Petri net model and a real plant is inevitable and leads to a decrease in the MPC’s reliability. To tackle this issue, we introduce a feedback correction mechanism in the proposed Petri-net-based MPC method.

Definition 8. 

Given the k-th firing transition $e_k$, its workspace is the set of operations whose ending events are modeled by $e_k$ in the Petri net model, which is denoted by $O\left(e_k\right)$.

Definition 9. 

Given the k-th firing transition $e_k$, the feedback time ${\alpha }_k$ is the function mapping from its workspace to the real number set, where $\forall o\in O\left(e_k\right)$, ${\alpha }_k\left(o\right)$ is the difference in the actual ending and beginning times of o.

As a plant runs, events are executed one by one and are modeled by transitions in its Petri net model. Once a transition fires, we can calculate the real processing times of the operations that have been completed. According to Definitions 8 and 9, the real processing times are represented by ${\alpha }_k$ and are fed back into the MPC such that the delays of the corresponding places can be corrected.

In a real plant, there are devices that are prone to breakdown. If a device is damaged suddenly, the operations relying on it cannot be performed. Hence, we need to re-model the plant.

Definition 10. 

At the k-th moment, the fault-event ${\eta }_k:D\to \{0,1\}$ is the function mapping from a resource set to $True\left(1\right)$ or $False\left(0\right)$, and $\forall \varpi \in D$, if ϖ breaks down, ${\eta }_k\left(\varpi \right)=1$; otherwise, ${\eta }_k\left(\varpi \right)=0$.

According to Definition 10, we can identify the damaged devices by the fault event, determine the operations that cannot be performed, and correspondingly revise the process graph $(\zeta ,\psi )$. Then, we can correct the Petri net model via Algorithm 1.

For a state $X_k$, its leaf nodes are obtained by firing k transitions from the initial state, and the leaf nodes are stored in the leaf node set ${\mathrm{\Phi }}_k$.

In order to calculate the scheduling strategy and control instructions, we proposed the Petri-net-based MPC method for a batch chemical system, which is summarized in Algorithm 2.

Algorithm 2: Petri-net-based MPC for batch chemical plants

Algorithm 2 consists of four functions: rolling optimization, place delay model correction, fault event model correction, and rush order model correction. The first one is to calculate a control action in each time step, and the others are responsible for correcting the Petri net model according to the feedback data.

Step 1 is to initialize the elements. Steps 2–9 make up a loop, where the state $X_k$ variable is the cyclic variable. In every iteration, the rolling optimization function, place delay model correction, fault event model correction, and urgent order model correction are respectively called according to the state feedback. The loop stops, and the algorithm exits until the target state is reached. In Steps 9–16, the rolling optimization function seeks to generate the reachability graph with the limited depth defined by the prediction domain H, to evaluate each leaf node by the heuristic function, and to identify the most promising transition $e_k$. After firing $e_k$, the next marking $m_{k+1}$ is obtained and can be used to determine all marked operation places. We can in turn obtain all the operations being carried out in $m_{k+1}$ and the valve instructions according to the resource requirement function. In Steps 17–21, the place delay model correction function updates the delays of places if the operation time in the operation set ${\alpha }_k$ is not equal to d. In Steps 22–25, the fault event model correction function computes the new process graph $(\zeta ,\psi )$ and regenerates the place-timed Petri net model by using Algorithm 1. In Steps 26–29, the urgent order model correction updates the markings of the batch-head places when an urgent order suddenly arrives.

Algorithm 2 combines the model predictive control method and the heuristic searching algorithm. It is able to flexibly adjust the depth of the reachability graph via the prediction time domain and quickly correct the system model according to the feedback.

7. Experiments

In order to verify the Petri-net-based MPC method, a series of numerical experiments are carried out on the batch chemical plant, as shown in Figure 1. We develop the Petri-net-based MPC Visual Studio 2017 simulation program in C++, and it is run on a computer with an i7-11700K 3.6 GHZ CPU and 32.0 GB RAM.

To evaluate the performance of the rolling optimization function in the proposed MPC algorithm, we conduct six experiments without an abrupt event, and the results are summarized in

Table 2. Experiments on the Petri-net-based MPC algorithm without an abrupt event.

Experiments		Dijkstra	Petri-Net-Based MPC
			Predication Domain H = 10		Predication Domain H = 30
No.	Batch size	Makespan (min)	Makespan (min)	Search time (ms)	Makespan (min)	Search time (ms)
1	10	19.96	20.23	4.9	19.96	9.1
2	20	44.30	44.60	18.6	44.35	25.6
3	30	69.60	70.10	24.1	69.70	44.1
4	40	96.63	97.21	53.2	96.86	56.8
5	50	121.75	122.25	81.8	121.90	84.6
6	60	147.10	147.45	88.9	147.10	89.4

.

As shown in Table 2, the Dijkstra algorithm is used to obtain the optimal solutions, and two Petri-net-based MPC algorithms are applied, where the prediction times are, respectively, 10 and 30. In the Petri-net-based MPC experiments, the mean search times per step are no more than 90 ms. Hence, we can conclude that the MPC method can schedule the plant in real time.

The average makespan in the six experiments using the MPC method is within 0.5% of the average makespan of the Dijkstra method. Hence, our MPC method can obtain a near-optimal solution to the scheduling issue of the plant.

Furthermore, the makespans of the MPC with the predication time of 30 are closer to the optimal ones than those with the predication time of 10. This means that we can approach the optimal solutions by increasing the prediction time domain if we obtain enough computational resources.

To evaluate the MPC methods with different prediction time domains, we draw Gantt graphs of Experiment 1, as shown in Figure 3. It is evident that there are major differences between the scheduling schemes. This implies that it may be worth paying greater computational costs.

To evaluate our MPC method with model correction, we conducted three experiments, which adopted the process adjustment event, urgent order event, and equipment damage event, respectively. The results are summarized in

Table 3. Experiments on the Petri-net-based MPC with abrupt events.

Experiments		No Model Correction Predication Domain H = 10	Model Correction Predication Domain H = 10
No.	Batch size	Makespan (min)	Makespan (min)
7	10	20.23	19.17
8	10	N/A	23.65
9	10	N/A	25.43

.

In Experiment 7, there are five abrupt events, in which the durations of $o_8$, $o_9$, $o_{10}$, $o_{11}$, and $o_{12}$ change to 90 s, 100 s, 110 s, and 130 s, respectively. Once such an abrupt event occurs, the place delay model correction function is called to correct the delays of the places, and the rolling optimization function computes control actions with the new Petri net model. The executive process of the plant is shown in the Gantt graph, as shown in Figure 4. The makespan without model correction is 20.23 min, while that with model correction is 19.17 min. This means that the model correction function is useful to improve the scheduling solution.

In Experiment 8, two urgent orders occur at 154 s and 172 s, respectively. The MPC algorithm is able to immediately adjust the schedule so that all orders are completed in 23.65 min.

In Experiment 9, the filters $f_1$ and $f_2$ are damaged at 465 s and 849 s, respectively. The MPC algorithm is able to regenerate the Petri net model immediately and recompute the scheduling strategy. As a result, the makespan is 25.43 min, which reflects the strong robustness of our MPC method.

From the above-mentioned results, our MPC method is able to compute the schedule scheme in real time and is robust enough to adapt to abrupt events. Further, its solution is very close to the optimal one.

8. Conclusions

The Petri-net-based MPC method is presented to schedule a batch chemical plant in real time. It consists of two algorithms. The first one aims to design the Petri net model automatically for a given batch chemical system. The second is made up of the rolling optimization function and three model correction functions. The proposed method allows the system to continuously optimize resource allocation while performing tasks, thereby achieving an efficient and intelligent production process.

The heuristic function and the predictive time domain are two important issues that affect the performance of the proposed method. However, the fixed prediction time domain limits the search area in the state space and this leads to a sacrifice in the quality of the scheduling strategy. In the future, we aim to improve the heuristic function via deep learning and to explore a method to dynamically adjust the prediction domain time such that the makespan can be shortened.