Simultaneous Framework for Dynamic Optimization Based on Density Functions

Abstract

Regarding the discretization issue in the process of a simultaneous approach for dynamic optimization problems, a configuration strategy based on the density function has been proposed for the finite element distribution of dynamic optimization problems. By utilizing the error at the non-collocation points, a bilevel problem has been constructed and solved, and the number and distribution of the finite elements have been evaluated. For the inner problem in the bilevel problem, a new smoothing function has been introduced to improve the solution accuracy of the inner problem. The grid density function has been constructed using the error at the non-collocation points on each finite element. Finally, the grid density function has been used to update the positions of the finite element endpoints, with the aim of reallocating the finite elements. Finally, two case studies have been provided to specifically demonstrate the role of the proposed method in reducing the optimization problem scale with required solution accuracy.

1. Introduction

Dynamic optimization is widely used in process systems engineering, with high demands for real-time solving in specific applications such as nonlinear model predictive control (NMPC) and online parameter estimation [1,2,3]. When using a direct approach to solve dynamic optimization problems, the original problem needs to be discretized first. Currently, the most popular discretization methods include the finite element method [4,5,6], the multiple shooting method [7,8,9,10], and control vector parameterization [11,12]. The control vector parameterization method only discretizes the control variables, which results in smaller problem sizes and significant speed advantages in solving. However, collocation may struggle to meet precision requirements and cannot effectively solve problems with state constraints. While the multiple shooting method enhances solution accuracy, the additional computation of sensitivity matrices during the solving process increases complexity. The simultaneous solution method based on finite element collocation discretizes both state and control variables, allowing for the direct treatment of path constraints and achieving higher precision. Nevertheless, the size of the resulting nonlinear programming problem after discretization is closely related to the number and distribution of selected finite elements. Generally, the more segments the finite elements are divided into in the time domain, the smaller the error in the numerical solution. However, more finite elements imply a larger scale of the nonlinear programming problem, leading to longer solving times. Similarly, reducing the number of finite elements can speed up solving but might compromise precision.

In order to simultaneously improve the numerical accuracy and efficiency of discretely solving ordinary differential equations (ODEs) and differential algebraic equations (DAEs), Wright et al. [8] devised a strategy for adaptive mesh refinement using finite elements by employing subdivision criteria functions. These criteria functions are designed to consider the impact of the size of individual finite elements on errors in other finite elements, and they are applied to solve two-point boundary value problems. Auzinger et al. [10] proposed a new estimation method for the global error resulting from discretization using the finite element collocation method and provided a comprehensive analysis of the correctness of this method when applied to general nonlinear regularization problems. Furthermore, Auzinger et al. [13] later introduced a method for globally equalizing errors. Starting from a coarse equal distribution of finite elements, this method refines the elements to ensure that errors generated in each segment of finite elements are uniformly distributed, effectively meeting user-specified accuracy requirements. This refinement strategy has shown good results in the numerical solution process of singular optimal control problems. Wright [14] employed an adaptive piecewise polynomial interpolation method to solve two-point boundary value problems, categorizing finite element refinement strategies into two types: for elements with small and evenly distributed errors, a subdivision strategy based on the previous finite element distribution is used; for elements with large and unevenly distributed errors, endpoints of the original finite elements need to be removed and the finite element allocation needs to be redone.

Vasantharajan and Biegler [15] introduced error constraints into the process of solving dynamic optimization problems to ensure more accurate and reliable results. To control approximation errors, the authors developed two different strategies: the error uniform distribution method and the error enforcement constraint method. These strategies are embedded in the solving process of the nonlinear programming problems obtained after discretization, and they adaptively adjust the lengths of finite elements during the optimization process. In the work of Seferlis and Hrymak [16], a method was employed to insert new grid points adaptively into finite elements to alter the distribution of the grid, thereby enhancing the numerical solution accuracy. The new grid distribution evenly distributes errors in the solution results across each finite element. Additionally, Tanartkit and Biegler [17,18] proposed a dual-layer strategy where the outer problem determines the number of finite elements required to meet a given tolerance, while the inner problem aims to solve the dynamic optimization problem and pass the solution results to the outer problem. Subsequently, Biegler et al. [19] further improved this strategy by introducing a simultaneous method based on error estimation. By adjusting the sizes of finite elements and the distribution of grid points in the mesh, this method captures switching points of control variables in optimal control problems and redistributes the grid based on the positions of these switching points to ensure precise control and state curves. Huntington and Rao [19] improved solution accuracy by varying the number of finite elements. They compared the global and local implementations of the orthogonal collocation method for solving optimal control problems to determine the accuracy and computational efficiency of each method. In the local method, the number of collocation points within each finite element remains constant while the number of elements changes. The global collocation form uses a single finite element over the entire interval with varying collocation point numbers. Zhao and Tsiotras introduced a method of grid point allocation using density functions [20], with the key aspect being the choice of the density function. By constructing a density function based on prior knowledge gained from previous solutions, grid point positions in the discretized mesh are recalculated using the density function, leading to more accurate results when solving the problem with the new mesh. Additionally, Darby et al. [21,22] proposed an hp-adaptive pseudospectral method. It divides the entire time domain into multiple intervals based on the curvature of the control trajectory. For intervals where the control trajectory is sufficiently smooth, the method of enhancing interpolation order (p-method) achieves faster accuracy improvement within a subinterval. For less smooth intervals, the method of subdividing the subintervals (h-method) works better. This method enables the use of pseudospectral methods to solve complex optimal control problems where global pseudospectral methods are not feasible. However, it requires multiple iterations to solve nonlinear programming problems, increasing computational burden. Consequently, using this method for online applications, especially for large-scale dynamic optimization problems, can be challenging. Paiva and Fontes [23] proposed an adaptive time mesh algorithm considering different refinement levels. The algorithm utilizes information from adjoint multipliers for grid refinement. However, in the process of solving optimization problems, the computational burden increases due to the addition of excessive new collocation points during grid refinement. In subsequent research, Paiva [24] introduced a time mesh refinement strategy based on local errors. After computing the solution on a coarse mesh, local errors are evaluated, providing information on the time subintervals that require refinement. This process is repeated until the local errors reach a user-specified threshold.

In recent years, Tamimi et al. [25] proposed a method for selecting the number of finite elements segments tailored to model predictive control. This method constructs a new optimization problem based on prior information obtained from the previous solution, including the solution time, objective function values, and the number of finite elements. It aids in selecting a “compromise” number of time intervals to achieve the desired accuracy. Subsequently, Haman et al. [26] enhanced the accuracy of the method by increasing the polynomial approximation order and the number of finite elements in each segment. They also merged adjacent grids that already met the accuracy requirements to reduce grid size and improve solution speed. Miller [27] utilized step functions to detect discontinuities in control trajectories and applied targeted refinement methods to adjust the discretized grid in different regions, thereby enhancing solution accuracy and efficiency. This approach is particularly effective for addressing optimal control problems with discontinuous control solutions, providing accurate numerical solutions within fewer iterations and a lower computational time. Furthermore, Huang et al. [28] introduced an adaptive grid allocation method based on pseudospectral techniques. Initially, they estimated the polynomial order based on the error between dynamics and state variable differential approximations in the spectral matrix. Subsequently, they determined whether to segment intervals based on the maximum polynomial order within the intervals. Finally, the positions of grid points were obtained as decision variables during the process of solving the optimal control problem.

Li et al. [29] proposed a novel bilevel method where an inner layer initially estimates the prior error. By constructing and solving a maximization problem, they obtain an upper bound on the approximate error. In the outer layer, the number of finite elements is treated as a decision variable to determine the minimum number of finite elements that satisfy a user-specified tolerance. The computation process of this method is intricate because in each iteration of the outer layer, the number of finite elements is uniformly increased by one segment, and then the maximum discretization error is solved internally and passed on to the outer layer for further iterative grid updates. Although after multiple iterations a grid satisfying the specified tolerance can be obtained, the grid update process in each iteration only utilizes the maximized error from the previous solution, leading to a relatively slow update pace for the distribution of finite elements. Zhao et al. [20] utilized the local curvature function of the control variable u as a density function for iterating over finite elements. They redistribute the finite elements based on the magnitude of the curvature of the control curve, densifying the finite element distribution where the local curvature function has a large value and making it sparser where the curvature function value is small.

In this study, inspired by the work of Li et al. [29], a bilevel strategy is employed to assess whether the discretized grid meets the user-specified tolerance requirements. However, a different approach is taken for updating the discretized grid using the concept of a grid density function. The selection of the density function and the calculation of grid point positions differ from the methodology proposed by Zhao [20]. Using the control trajectory curvature as the grid density function presents several distinct drawbacks. Firstly, the grid density function determined by this method tends to have relatively high calculation errors. In the work by Zhao, the calculation method for local curvature is relatively simplistic, leading to the loss of crucial information during computation and resulting in the density function not accurately reflecting the true control curvature. Secondly, the approach for selecting the grid density function in the literature lacks universality. For certain highly sensitive issues, using curvature as the grid density function may not yield optimal results. This study constructs the grid density function based on errors at non-collocation points within each finite element. Modifications have been made to the calculation method for grid points, enhancing the accuracy and convenience of refining the discretized grid using the grid density function. Moreover, by combining this refined bilevel approach, a more precise determination of the minimum number of finite elements in the discretized grid that satisfies the user-specified accuracy criteria can be achieved.

2. Description of Problem

This paper research the following form of nonlinear dynamic optimization problem:

$$\begin{array}{ll}\underset{u(t)}{\min }& :J = M(x(t_f))+{\displaystyle {\int }_{t_0}^{t_f}L(x(t),u(t),t)dt}\\ s.t.& \dot{x}(t)=f(x(t),u(t),t)\\ & x(t_0)=x_0\\ & x_{\min }\le x(t)\le x_{\max }\\ & u_{\min }\le u(t)\le u_{\max }\\ & t\in [t_{0,}{t}_f]\end{array}$$

(1)

In this problem, x(t) ∈ R^nx and y(t) ∈ R^ny represent the vectors of differential and algebraic state profiles, respectively; and the control profiles u(t) $\in R^{nu}$ are bounded by ${\mathit{u}}_{\mathrm{l}}$, ${\mathit{u}}_u\in R^{nu}$, respectively; $\mathit{f}:R^{nx+ny+nu}\to R^{nx}$, $\mathit{g}:R^{nx+ny+nu}\to R^{ny}$ are three times differentiable functions [30]. Moreover, both the control variable u(t) and the state variable x(t) are subject to constraints. To solve this problem using a coupled method based on finite element orthogonal configuration, we need to select a discretization method and determine several time intervals to transform it into a nonlinear programming problem to achieve a numerical solution. The specific discretization process is as follows:

The optimal control problem is transformed into an NLP (nonlinear programming) using the finite elements method. First, the continuous time domain is discretized into a finite number of finite elements [t_i−1, t_i], i = 1, …, N, which satisfies

$$t_0<t_1<t_2<\dots <t_{N-1}<t_N=t_f$$

(2)

where t₀ and t_N are fixed and where grids t₁, …, t_N−1 may become variables. Lagrange interpolation polynomials using either Gauss or Radau points on each finite element are adopted as follows [31]:

$$\left\{\begin{array}{l}{x}^K(t)={\displaystyle \sum _{k=0}^K{l}_k(\tau )x_{ik}}\\ u^K(t)={\displaystyle \sum _{k=0}^K{\overline{l}}_k(\tau )u_{ik}}, y^K(t)={\displaystyle \sum _{k=0}^K{\overline{l}}_k(\tau )y_{ik}}\\ t_i=t_{i-1}+h_i\tau , h_i=(t_i-t_{i-1}), \tau \in [0,1]\\ l_k(\tau )={\displaystyle \prod _{j=0,\ne k}^K\frac{\tau -{\tau }_j}{{\tau }_k-{\tau }_j}, {\overline{l}}_k(\tau )={\displaystyle \prod _{j=1,\ne k}^K\frac{\tau -{\tau }_j}{{\tau }_k-{\tau }_j}}}\end{array}\right.$$

(3)

where K is the number of collocation points. Lagrange polynomials have the additional benefit of satisfying the following conditions:

$$\begin{array}{l}{t}_{ik}=t_{i-1}+(t_i-t_{i-1}){\tau }_k\\ x^K(t_{ik})=x_{ik}, u^K(t_{ik})=u_{ik}, y^K(t_{ik})=y_{ik}\end{array}$$

(4)

with the collocation equations written as [31]

$$\begin{array}{l}{\displaystyle \sum _{j=0}^K{\dot{l}}_j({\tau }_k)x_{ij}-h_{i}f(x_{ik},y_{ik},u_{ik})}=0\\ g(x_{ik},y_{ik},u_{ik})=0,i=1,\dots ,N;k=1,\dots K\end{array}$$

(5)

the continuity of the differential state profiles is enforced by the following equation [31]

$$x_{i+1,0}={\displaystyle \sum _{j=0}^K{l}_j(1)x_{ij},i=1,\dots ,N-1}$$

(6)

After discretizing the problem and transforming it into the form of a nonlinear programming problem, it is necessary to assess the errors generated during the discretization process. Since at the collocation points the numerical and analytical values of the state are nearly identical within a tolerance range [31,32], there is no need to discuss the approximation errors at these points during the analysis of the discretization errors. Instead, the focus should be on analyzing the errors at non-collocation points, using them as a metric to gauge the accuracy of the solution. Theoretically, the number of non-interpolated points is infinite, which complicates error estimation. To address this challenge, it is essential to select a distinct non-collocation point within each time interval for error analysis. We adopt the same approach as Li et al. [29] by using non-collocation points for error estimation. Consequently, the error $e({\tilde{t}}_i)$ at each finite element non-collocation point is expressed as

$$e(\widetilde{t_i})=\left|x(\widetilde{t_i})-x_N(\widetilde{t_i})\right|, i\in \{1,\dots ,N\}$$

(7)

where $\widetilde{t_i}$ represents the position of the non-collocation point on the ith finite elements, and $x_N\left(t\right)$ denotes the value of the state variable obtained from the discretized grid after adding a grid point at the non-collocation point.

3. Description and Improvement of the Bilevel Method

In the work by Li et al. [29], a bilevel problem was proposed to determine the number of finite elements, where the inner bilevel method involves formulating a dynamic optimization problem that maximizes the error. The error maximization problem can be described as

$$\begin{array}{ll}\underset{u,s}{\max }& : s\\ \mathrm{s}.t.:& {\displaystyle \sum _{j=0}^{nc}{\dot{l}}_j({\tau }_k)x_{ij}-h_{i}f(x_{ik},u_{ik})},i=1,\dots ,N,k=1,\dots ,nc\\ & \underset{i\in \{1,\dots ,N\}}{\max }\{e^q({\widehat{t}}_i)\}-s=0\\ & x_{\min }\le x_{p,i}\le x_{\max },i,\dots ,N\\ & u_{\min }\le u_i\le u_{\max }\\ & s_{\min }\le s\le s_{\max }\end{array}$$

(8)

where $e^q({\widehat{t}}_i)=\left|x^q({\widehat{t}}_i)-x_N^q({\widehat{t}}_i)\right|$. Additionally, $s\in R^1$ represents the maximized error, and q denotes the number of components of the state variable x. The upper and lower bounds of the error maximization problem constructed are the same as the original problem, with the upper and lower bounds for maximizing the error s being s_max = 1, s_min = 0, respectively. When solving this inner layer problem using a nonlinear solver, the presence of non-smooth absolute value and maximum value symbols in Equation (8) poses a challenge that derivative-based optimization methods cannot directly handle. Therefore, it is necessary to smooth out these non-smooth regions.

In the method proposed by Li et al. [29], a softmax function is utilized to smooth out these two non-smooth constraints:

$$\begin{array}{l}\max \{\left|\alpha \right|,\left|\beta \right|\}=\ln (\exp (\left|\alpha \right|)+\exp (\left|\beta \right|))\\ \left|\alpha \right|=\max \{\alpha ,-\alpha \}=\ln (\exp (\alpha )+\exp (-\alpha ))\end{array}$$

(9)

however, during the calculations, it was observed that a significant error is introduced when smoothing is performed using Equation (9). For instance, when applying Equation (9) for smoothing, the resulting function graph is compared with the original function graph, as shown in Figure 1.

In Figure 1, the function |t| with the absolute value symbol is smoothed using Equation (9). It can be observed from the graph that the smoothing effect is not ideal, especially near zero where the smoothed function values deviate significantly from the original function values. Moreover, the errors calculated using the inner methods are often very small. Therefore, when applying Equation (9) for smoothing, these errors become substantially large, failing to accurately reflect the actual error values. Consequently, using Equation (9) to smooth functions with absolute value symbols is not advisable. Additionally, the removal of the maximum value symbol in Equation (9) for smoothing also introduces errors that need to be addressed. Hence, this paper proposes a new smoothing strategy that can better approximate the actual results.

$$\left\{\begin{array}{l}a=a_{+}-a_{-}\\ a_{+}\cdot a_{-}=0\\ a_{+}\ge 0,a_{-}\ge 0\end{array}\right.\Rightarrow \left|a\right|=a_{-}+a_{+}$$

(10)

In Equation (10), two non-negative functions are used to replace the absolute value function [33]. Furthermore,

$$\max \{a,b\}={\displaystyle \frac{a+b}{2}}+\left|{\displaystyle \frac{a-b}{2}}\right|$$

(11)

the approach of eliminating the max function using Equation (11) is shown to be entirely equivalent and does not introduce errors. In practical applications, let

$$\left\{\begin{array}{l}a=a_{+}-a_{-}\\ a_{+}\cdot a_{-}={\epsilon }_a\\ a_{+}\ge {\epsilon }_a,a_{-}\ge {\epsilon }_a\end{array}\right.$$

(12)

where ${\epsilon }_a$ is a very small positive integer. Compared to Equation (9), the smoothing errors generated by using Equations (10) and (12) are smaller. This enables the inner method to better reflect the actual error values during the process of maximizing error.

In contrast to the inner method, the design of the outer method is relatively concise. It involves passing the maximum error calculated by the inner method and comparing it with the given tolerance. Based on this comparison, the positions of the finite element nodes are updated. This can be specifically expressed as follows:

$$\begin{array}{l}\underset{N^{(l)}}{\min }:\{N^{(l)}\}\\ s.t.:e_{\max }^{(q)}\le \epsilon \end{array}$$

(13)

where l denotes the iteration number and N represents the size of the discretized grid. N is updated after each iteration as follows: N = N + 1. Then, based on the updated value of N, the time domain is uniformly partitioned to create a new distribution of finite elements. If the maximum non-collocation point error is less than the user-defined tolerance, then N is set as the minimum number of finite elements.

4. Finite Element Allocation Strategy Based on Density Function

The grid density function is a non-negative function $\overline{f}:[a,b]\to R_{+}$,$a, b\in R$ that satisfies an integral value of 1 over the interval [a, b]. According to the definition, any non-negative function $\overline{f}:[a,b]\to R_{+}$ can be considered as a standard grid density function if it has only a finite number of zeros within its domain:

$$\overline{f}(t)={\displaystyle \frac{f(t)}{{\displaystyle {\int }_a^{b}f(\tau )d\tau }}}$$

(14)

Assuming that any grid density function used for finite element refinement has been normalized, implying that its cumulative distribution function F has its domain transformed from [a, b] to [0, 1], the calculation method is as follows:

$$F(t)={\displaystyle {\int }_0^t\overline{f}}(\tau )d\tau$$

(15)

Clearly, F(0) = 0 and F(1) = 1. The time domain [a, b] can be normalized to [0, 1] and discretized into a grid of size N + 1 to obtain grid points ${\left\{t_i\right\}}_{i=0}^N$, where t₀ = 0 and t_N = 1. Given a grid density function, the position of the i-th point in the grid can be represented as follows:

$$F(t_{i+1})-F(t_i)={\displaystyle \frac{1}{N}}$$

(16)

Therefore, a new finite element distribution can be generated based on this grid density function, where the density of the finite element endpoints is entirely determined by the magnitude of the density function.

As per the definition, the grid density function only needs to be non-negative (and integrable). The specific choice of the density function for calculating the grid distribution can maximize both the accuracy and efficiency of the solution. In this paper, a different approach and method are adopted for calculating and selecting the density function compared to Zhao et al. [20]. After solving with the inner method, the errors at the non-collocation points on each finite element can be determined. By comparing these errors, the distribution of errors at non-collocation points on each segment can be understood, and segments that do not meet the user-defined tolerance can be identified. Segments with large non-collocation point errors can be further refined to ensure that the discretization errors at non-collocation points on the finite elements meet the user-defined tolerance for subsequent solving processes. However, refining only in areas with large errors does not guarantee that the errors at non-collocation points across the entire time domain of the finite elements will meet the specified tolerance. Previous experimental results suggest that refining only the segments that do not meet the error criteria can lead to new non-collocation points violating the specified tolerance within previously compliant segments. Therefore, the refinement of the discretized grid update cannot simply focus on the segments containing non-collocation points that do not meet the specified tolerance after a single solving iteration.

The errors can be processed by solving with the inner method at the non-collocation points on each segment of the finite element obtained. The error rate of each segment of the finite element can be calculated by dividing the error at each non-collocation point on that segment by the sum of the absolute values of errors at all the non-collocation points on all the segments of the finite element. This ratio is denoted as $e_i^p=\left|e(\widetilde{t_i})\right|/(\sum _{i=1}^N\left|e(\widetilde{t_i})\right|),i\in 1$, …, N, using $e_i^p$ as an indicator to construct the error function e(t); e(t) is viewed as piecewise constant over the entire time domain, where its value on each segment of the finite element is denoted as $e_i^p$. Therefore, we can derive the grid density function f(t) based on the error function e(t).

$$f(t)={\displaystyle \frac{e(t)}{{\displaystyle {\int }_{t_0}^{t_N}e(t)}}}$$

(17)

Similarly, the grid density function f(t) is also a piecewise function. Although the piecewise form of f(t) may result in some loss of accuracy during grid point allocation, compared to the density function constructed using cubic spline functions as carried out by Zhao et al. [20], the cost of computation is significantly reduced, enhancing the overall efficiency of the algorithm. Furthermore, as demonstrated in subsequent cases, it also achieves the goal of finite element refinement.

In the computation process of finite element endpoints using the grid density function, the differences in the cumulative probability density function values calculated at adjacent finite element endpoints are equal, being $1/N$. Thus, during each grid update, the updated positions of the finite element endpoints can be calculated using the density function.

This study utilizes a grid density function for solving the finite element endpoints. ${\left\{t_i\right\}}_{i=1}^{N-1}$ represents the computed finite element endpoints, where t₀ = 0 and t_N = 1:

$${\displaystyle \frac{i-1}{N-1}}={\displaystyle {\int }_0^{t_j}f(\tau )d}\tau ,j\in 2,\dots ,N-1$$

(18)

According to Formula (18), the updated finite element endpoints can be calculated using the grid density function. However, the obtained distribution of finite elements cannot be directly utilized in the subsequent iterative calculations. In practical operations, the computed distribution of finite elements often fails to meet the requirements and violates the principle of finite element allocation using density functions: allocating more finite elements in regions with higher density function values. During the process of finite element endpoint calculation, the distribution of finite elements from the previous iteration affects the allocation results of the next iteration. Since the computation of grid points is determined by the cumulative probability density function, and the sizes of finite elements in each segment obtained in subsequent iterations are inconsistent, the sizes of finite elements and the cumulative probability density function are correlated. As a result, finite elements that should have been further refined may not be adequately refined because in the previous distribution of grid points, the segment was too small, causing the corresponding value of the cumulative probability density function to decrease, resulting in fewer computed finite element endpoints. This limitation prevents the further refinement of finite elements with higher density functions. Conversely, for finite elements with initially lower grid density functions, if the element lengths were larger in the previous allocation, their cumulative density function values would increase, leading to the allocation of more finite element endpoints. Based on these scenarios, this study has improved the generation of finite element endpoints. The algorithm for updating finite element endpoints is as follows:

(1)

First, record the finite element distribution obtained from the previous solution as the original distribution, as shown in Figure 2, and derive the error density function based on the errors at non-collocation points on each segment of the original distribution.

(2)

Uniformly redistribute the entire time domain without changing the number of finite elements, ensuring that the length of each segment of finite elements is equal, as illustrated in Figure 3.

(3)

Under the assumption of a uniform distribution of finite elements, construct the grid density function based on Formula (17):

$$f_i={\displaystyle \frac{e(\widetilde{t_i})}{{\displaystyle \sum _{i=0}^N(e(\widetilde{t_i})\times \frac{N}{Tf}})}},i\in 1,\dots ,N$$

(19)

(4)

Based on the values of the grid density function, calculate new finite element endpoints within the uniformly distributed finite elements using Formula (19). Record the relative positions of the new finite element endpoints within each segment of finite elements.

(5)

Map the finite element endpoints from the uniformly distributed finite elements back to the original finite element distribution based on their relative positions within each segment. This process results in the updated finite element distribution. For example, if a grid point in the ith segment within the uniformly distributed grid is located at 2/5 of that segment’s length, it will be mapped back to the non-uniform grid at the 2/5 position of the ith segment, representing the location of the newly generated grid point, as shown in Figure 4.

In the process of generating the grid density function using the error function, there may be extreme cases. For instance, when calculating the errors at non-collocation points of certain finite elements, the errors might be extremely small, leading to very small values of the grid density function for these elements. During subsequent finite element refinement, new finite element endpoints may not be allocated in these regions. While this aligns with the original intent of the density function design—allocating fewer finite elements in regions with small errors—there are too many neighboring finite elements with very small density values. However, we also want to appropriately allocate some collocation points to the finite elements that previously met the tolerance requirements for the finite element regions. Otherwise, there will be a violation of the tolerance requirements again in the regions of the finite elements that previously satisfied the user-specified tolerance. This is an undesired outcome, so

$$f_i=\left\{\begin{array}{l}{f}_i, f_i>\sigma \\ {\sigma }_m, f_i\le \sigma \end{array}\right.$$

(20)

In Formula (20), if the density function is less than a specified threshold, it is replaced by a relatively small constant value to prevent finite elements that originally met the error requirements from becoming ineffective again after grid updates. In conclusion, this section presents a new approach to constructing the grid density function, improving and optimizing the process of calculating finite element endpoints using the grid density function.

5. Overall Algorithm Flow

The overall algorithm flow for selecting the number and distribution of elements in dynamic optimization problems is provided below, divided into the following stages:

(1)

Determine the initial number of elements and convert the dynamic optimization problem into a nonlinear programming problem based on a uniform distribution.

(2)

Formulate a bilevel optimization problem to determine the number of elements using the original dynamic optimization problem. Calculate the maximum error at non-collocation points for each element through the inner problem. If the errors are all less than the user-defined tolerance and the iteration count is 0, it proves that fewer elements can precisely meet the user-defined tolerance. Decrease the number of elements by 1 and return to step (1) for resolution. If the iteration count is not 0 and meets the user-defined tolerance, the number and distribution of elements for this iteration are the minimum that meets the user-defined tolerance.

(3)

Construct an error function using the errors at non-collocation points on each element. Develop a mesh density function based on the error function for refinement in the current element.

(4)

Utilize the mesh density function to update element endpoints using the element endpoint updating algorithm. Increment the iteration count by one and return to step (1) for further resolution.

The general steps outlined above can be detailed as shown in the following Figure 5. Here, l represents the number of times the grid is updated, N is the number of elements, ε is the user-defined tolerance, and ∇N is the number of elements added in each iteration process.

6. Experimental Case

To illustrate the effectiveness of the proposed method, this section addresses two dynamic optimization problems: a bifunctional catalyst blend in a tubular reactor (BCBTR) and a nonlinear continuous stirred tank reactor (NCSTR). For the BCBTR problem, the optimal control profile is influenced by the initial guess, resulting in multiple optimal solutions. Consequently, the maximum approximation error varies among different control profiles. In the case of the NCSTR problem, the complexity arises from the interdependencies among three of the four control variables [29].

Using the grid distribution generated by the density function, the inner loop method was solved 300 times. Each solving process used randomized initial guesses to enhance the credibility of the resulting grid distribution. Since the multiple solving processes are independent, the 300 runs can occur in parallel. This also reduces the computational burden. According to the research in [29], if a high-priority state variable can be found and the maximum approximation error is defined based on that state variable, the errors of other state variables can also be calculated. In contrast, the state variable selected in this study for the experimental cases below is the same as that chosen by Li et al. in [29]. All cases were executed on a system running Windows Server 2012 R2 Standard, with a CPU model: Intel(R) Xeon(R) Silver 4112 CPU, operating at a frequency of 2.60 GHz, and equipped with 64 GB of RAM.

6.1. Bifunctional Catalyst Blend in a Tubular Reactor [29]

The problem is described as in Equation (21).

$$\begin{array}{l}\underset{u(t)}{\max }:x_7(t_f)\\ \hfill \mathrm{s}.\mathrm{t}.:& {\dot{x}}_1(t)=& -k_1(t)\cdot x_1(t)\\ & {\dot{x}}_2(t)=& k_1\cdot x_1(t)-(k_2(t)+\\ & & k_3(t))\cdot x2(t)+k_4(t)\cdot x_5(t)\\ & {\dot{x}}_3(t)=& k_2(t)\cdot x_2(t)\\ & {\dot{x}}_4(t)=& -k_6\cdot x_4(t)+k_5(t)\cdot x_5(t)\\ & {\dot{x}}_5(t)=& k_3(t)\cdot x_2(t)+k_6(t)\cdot x_4(t)\\ & & -(k_4(t)+k_5(t)+k_8(t)\\ & & +k_9(t))\cdot x_5(t)+k_7(t)\cdot x_6(t)\\ & & +k_{10}(t)\cdot x_7(t)\\ & {\dot{x}}_6(t)=& k_8\cdot x_5(t)-k_7(t)\cdot x_6(t)\\ & {\dot{x}}_7(t)=& k_9\cdot x_5(t)-k_{10}(t)\cdot x_7(t)\\ & x(t_0)=& {[1,0,0,0,0,0,0]}^T\\ & t_0\le t\le & t_f,t_0=0,t_f=2000\\ 0.6\le u(t)\le 0.9\end{array}$$

(21)

It is composed of seven differential equations, where x_i, for i = 1, …, 7, represents multiple components of the state variables. The k_i, for i = 1, …, 10, is defined as the cubic functions of the control variable u(t), as follows:

$$k_i=c_{i,1}+c_{i,2}\cdot u(t)+c_{i,3}\cdot u^2(t)+c_{i,4}\cdot u^3(t)$$

(22)

where the coefficients c_i,j, j = 1, …, 4, are obtained through experiments.

To a priori determine the minimum number of time intervals without a loss of generality, we selected the state variable x₇(t) for error analysis. This state variable describes the molar fraction of the product (benzene) [29]. By transforming the original optimization problem (21) into an inner problem within the bilevel method, we constructed a maximization problem for errors and solved it. The expression formula after the transformation using the bilevel method can be found in Appendix A. The results are presented in

Table 1. Comparison of results for tubular reactor problem.

$\mathit{\epsilon }$	Original Bilevel Method		Bilevel Method Based on Density Functions
	N	emax	N	emax
$2\times {10}^{-5}$	10	$1.927\times {10}^{-5}$	7	$1.131\times {10}^{-5}$
$1\times {10}^{-5}$	21	$9.556\times {10}^{-6}$	9	$8.542\times {10}^{-6}$
$5\times {10}^{-6}$	37	$4.948\times {10}^{-6}$	21	$4.962\times {10}^{-6}$

.

As shown in Table 1, as the demand for solution accuracy increases, the given tolerance gradually decreases. Consequently, the required number of time intervals to meet the tolerance also increases. The maximum errors obtained are less than the corresponding tolerance values. Furthermore, when the user-defined tolerance is set to 2 × 10⁻⁵, it takes 10 time intervals to meet the given tolerance without partitioning through the density function. After solving and utilizing the error information obtained to partition the grid using the density function, only seven finite elements are needed to meet the given tolerance. For other tolerance settings as well, the advantages of grid partitioning based on the density function in terms of solution efficiency and accuracy can be demonstrated.

6.2. A Nonlinear Continuous Stirred Tank Reactor [29]

This problem was originally proposed by Luus and further analyzed by Balsa-Canto et al. The problem is defined as in Equation (23). The controls involve the flow rates of three feed streams and the electrical power input for photochemical reactions. The system dynamics are described by several simultaneous chemical reactions [29]. This particular problem is challenging due to the highly nonlinear nature of the system and the complexity of the optimal control profiles. Transforming problem (23) into the inner problem within the bilevel method, the determination was based on the maximum approximation error of the state variable x₁(t). The expression formula after the transformation using the bilevel method can be found in Appendix A. The results of the solution are presented in

Table 2. Comparison of results for NCSTR problem.

$\mathit{\epsilon }$	Original Bilevel Method		Bilevel Method Based on Density Functions
	N	emax	N	emax
$1\times {10}^{-3}$	8	$6.228\times {10}^{-4}$	8	$7.125\times {10}^{-4}$
$1.125\times {10}^{-4}$	12	$1.191\times {10}^{-4}$	11	$9.45\times {10}^{-6}$
$5\times {10}^{-6}$	22	$4.4\times {10}^{-6}$	17	$1.039\times {10}^{-7}$

. The results indicate that a larger grid of discretization is required when the accuracy of the state trajectory is higher. Similarly, the advantage of the discretization grid determined using the density function-based bilevel method is particularly evident in scenarios where high precision is demanded. Moreover, the discretization grid determined by this method yields maximum errors in the inner problem that are smaller when a higher precision is required compared to the maximum errors produced by methods not utilizing the density function.

$$\begin{array}{l}\underset{u(t)}{\max } x_8(t_f)\\ \mathrm{s}.\mathrm{t}.:{\dot{x}}_1(t)=u_4(t)-q\cdot x_1(t)-17.6\cdot x_1(t)\cdot x_2(t)-23\cdot x_1(t)\cdot x_6(t)\cdot u_3(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_2(t)=u_1(t)-q\cdot x_2(t)-17.6\cdot x_1(t)\cdot x_2(t)+146\cdot x_2(t)\cdot x_3(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_3(t)=u_2(t)-q\cdot x_3(t)-73\cdot x_2(t)\cdot x_3(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_4(t)=-q\cdot x_4(t)+35.2\cdot x_1(t)\cdot x_2(t)-51.3\cdot x_4(t)\cdot x_5(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_5(t)=-q\cdot x_5(t)+219\cdot x_2(t)\cdot x_3(t)-51.3\cdot x_4(t)\cdot x_5(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_6(t)=-q\cdot x_6(t)+102\cdot x_4(t)\cdot x_5(t)-23\cdot x_1(t)\cdot x_6(t)\cdot u_3(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_7(t)=-q\cdot x_7(t)+46\cdot x_1(t)\cdot x_6(t)\cdot u_3(t)\\ \hspace{1em}\hspace{1em}{\dot{x}}_8(t)=5.8\cdot (q\cdot x_1(t)-u_4(t))-3.7\cdot u_1(t)-4.1\cdot u_2(t)+q\cdot (23\cdot x_4(t)\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}+11\cdot x_5(t)+28\cdot x_6(t)+35\cdot x_7(t))-5\cdot {u_3}^2(t)-0.09\\ \hspace{1em}\hspace{1em}q=(u_1(t)+u_2(t)+u_4(t))\\ \hspace{1em}\hspace{1em}x(t_0)={[0.1883,0.2507,0.0467,0.0899,0.1804,0.1394,0.1046,0]}^T\hspace{1em}\\ \hspace{1em}\hspace{1em} 0\le u_1(t)\le 20,0\le u_2(t)\le 6\\ \hspace{1em}\hspace{1em}0\le u_3(t)\le 4,0\le u_4(t)\le 20\\ \hspace{1em}\hspace{1em}{t}_0\le t\le t_f,t_0=0,t_f=0.2\end{array}$$

(23)

7. Conclusions

In the process of solving dynamic optimization problems using a direct approach, the efficiency and accuracy of the solution can be enhanced by optimizing the number and distribution of finite elements during the discretization process. In this study, an improved bilevel method was utilized to select the number of finite elements, and error information generated by the inner method was used to construct a grid density function for refining the finite elements. Experimental cases have demonstrated that compared to traditional uniform distribution strategies for finite elements, the proposed approach can significantly reduce the scale of the solved problem while meeting user-specified accuracy requirements. The use of a grid density function for allocating finite elements resulted in a significantly lower number of finite elements compared to allocations without using a grid density function. For example, in Case 1, when the user-defined tolerance is set to $2\times {10}^{-5}$, the number of finite elements required to meet this tolerance using the method of Li et al. is 10. However, by utilizing the density function for allocation, only seven finite elements are needed to satisfy the user-defined tolerance. When the user-defined tolerance requirement is increased to $5\times {10}^{-6}$, using Li et al.’s method required 37 finite elements while using the density function only requires 21 finite elements.

Moreover, by enhancing the smoothing strategy for the inner method within the bilevel method, errors near zero points caused by the soft maximum function were eliminated, making the subsequent construction of the grid density function using errors at non-collocation points more precise. This improvement also increased the efficiency of solving the inner problem. However, there are areas for improvement in the method proposed in this study. In the future work, more attention can be paid to the errors of other state variables at non-configured points in order to collectively construct a joint error function, leading to a more accurate grid density function.