Abstract
This study proposes an algorithm to solve inverse reliability problems with a single unknown parameter. The proposed algorithm is based on an existing algorithm, the inverse first-order reliability method (inverse-FORM), which uses the Hasofer Lind Rackwitz Fiessler (HLRF) algorithm. The initial algorithm analyzed in this study was developed by modifying the HLRF algorithm in inverse-FORM using the Broyden-Fletcher-Goldarb-Shanno (BFGS) update formula completely. Based on numerical experiments, this modification was found to be more efficient than inverse-FORM when applied to most of the limit state functions considered in this study, as it requires comparatively a smaller number of iterations to arrive at the solution. However, to achieve this higher computational efficiency, this modified algorithm sometimes compromised the accuracy of the final solution. To overcome this drawback, a hybrid method by using both the algorithms, original HLRF algorithm and the modified algorithm with BFGS update formula, is proposed. This hybrid algorithm achieves better computational efficiency, compared to inverse-FORM, without compromising the accuracy of the final solution. Comparative numerical examples are provided to demonstrate the improved performance of this hybrid algorithm over that of inverse-FORM in terms of accuracy and efficiency.
1. Introduction
The reliability of structural members is a basic criterion of their design [1–6]. One of the widely used nonsimulation based methods for reliability estimation is the first-order reliability method (FORM) [7]. It uses a linear approximation of the limit state function. Nonnormal variables in their original space are generally mapped to the standard normal space. This is carried out to obtain the most probable point of failure, also called the design point. In the standard normal space, u is defined as a column vector of standard normal variables, and is defined as the limit state function. Note that all the vectors mentioned in this paper are column vectors. The design point is defined as the point on the limit state boundary (), which is closest to the origin.
In first-order reliability method (FORM), reliability index is estimated as the magnitude of the design point vector in the standard normal space; that is, when satisfies the following optimization condition: In an inverse reliability problem, a target reliability index is generally given, and an unknown parameter represented by in a limit state function is inversely calculated. In practical cases, can represent any parameter in a limit state function that must be chosen to obtain a specific level of reliability. The value of needs to be determined at the design point that satisfies and . The inverse reliability problem is defined by the following equation set: where is the gradient operator with respect to . Simply, the value of can be found by a trial and error method using a forward reliability procedure (e.g., FORM) and then interpolating the value of the unknown parameter for a specific reliability level. However, this method is tedious requiring computational costs [8], and inverse reliability algorithms are far more advantageous than direct reliability measures [9].
The solution for an inverse reliability problem can be obtained using several methods. A reliability contour method was developed by Winterstein et al. [10] and applied to problems in offshore structure problems. As an extension of this method to general limit states, Der Kiureghian et al. [11] developed an algorithm, inverse-FORM, which was based on the Hasofer Lind Rackwitz Fiessler (HLRF) algorithm [12–14]. This inverse reliability method was used by other researchers for various applications including extreme and nominal loads on wind turbines [15, 16] and critical earthquake loads [17]. This HLRF-based method was found to have a fast convergence as demonstrated by the numerical examples considered by Der Kiureghian et al. [11]. However, when the limit state function is highly nonlinear, this method may converge slowly [18].
In solving forward reliability analyses, sequential quadratic programming techniques such as the BFGS (Broyden-Fletcher-Goldfarb-Shanno) formula have been used in the literature [19, 20]. BFGS-based algorithms were found to be a cheaper alternative to HLRF-based algorithms in solving a certain set of problems [21, 22]. These algorithms were proved to be more robust than HLRF-based algorithms in solving forward reliability problems [14]. In addition, they were also found to be more efficient in solving large scale constraint-based reliability problems [23, 24]. Although this method has been used in solving forward reliability problems, this study is the first attempt to extend the applications of the BFGS formula to inverse reliability analysis.
In this paper, a hybrid inverse reliability algorithm based on the BFGS update formula is proposed. In inverse-FORM, the HLRF-based algorithm, the Hessian of the Lagrangian is approximated by the identity matrix for every iteration as shown by Periçaro et al. [18]. However, the proposed hybrid method uses the BFGS update formula in some iterations to calculate the Hessian of the Lagrangian.
Initially, when developing this hybrid algorithm, the idea of using the BFGS update formula for every iteration was tried as an intermediate algorithm. Although this modification improved the efficiency of solving the numerical examples, it affected the accuracy of the final solution. Hence, further modifications were made to arrive at the hybrid algorithm that uses the identity matrix in few iterations and the BFGS update formula in other iterations for approximating the Hessian of the Lagrangian. This hybrid algorithm achieves better efficiency without compromising the accuracy of the final solution. In the following sections, the mathematical formulations of inverse-FORM and the proposed hybrid algorithm are provided for inverse reliability analysis. The method proposed in this paper can be used to analyze the reliability of a component in a system.
2. Inverse-FORM Algorithm
The inverse-FORM algorithm was proposed by Der Kiureghian et al. [11] to solve (2a), (2b), and (2c). They proposed using a merit function to induce convergence to the solution and a step direction vector , which represents a direction vector towards the next searching point in the subsequent iteration. The merit function is composed of two subfunctions, and . ensures the convergence of the reliability index at the search point () to the target reliability index ; ensures that the search point converges to a point on the limit state boundary. The step direction vector () also has two parts: and . represents a direction vector towards the next values of the design variables in the subsequent iteration (). represents a direction constant towards the next value of the unknown parameter in the subsequent iteration ().
In the inverse-FORM algorithm, the first starting values for and are selected as and , respectively, and they are updated using the following equation until converged: where is the step size for the th iteration; is the step direction vector; and are the values of in the th and th iterations, respectively; and are the values of in the th and th iterations, respectively.
The step size in (3) is determined satisfying the following condition:where is the merit function given by the following equation:where and are given by the following equations:where is given by the following equation:The step direction vector () in (3) is calculated as follows:where , , , and are calculated as follows:where , , , and are calculated as follows:This inverse-FORM algorithm based on the HLRF algorithm successfully provided inverse reliability solutions as demonstrated by the two examples in the work done by Der Kiureghian et al. [11]. However, the algorithm converges slowly for highly nonlinear examples [18] and can be further improved by using the BFGS-based-hybrid algorithm that is proposed in the next section.
3. BFGS-Based Algorithm
3.1. Intermediate Algorithm
In this section, an intermediate algorithm that was developed by modifying the HLRF algorithm in inverse-FORM using the Broyden-Fletcher-Goldarb-Shanno (BFGS) update formula is explained. This intermediate algorithm uses calculation steps similar to those in inverse-FORM to solve an inverse reliability problem described in (2a), (2b), and (2c) incorporating the BFGS formula. The starting points for and are adopted as and , respectively, and the values of u and are updated using the step direction vector, using (3). The step size in (3) is found such that the condition in (4) is satisfied.
The difference of this intermediate algorithm is as follows: in the calculation of the merit function in (5), is calculated using the following equation instead of (6), while is calculated using (7) unchangingly:where is calculated as follows:Note that, in (18) and (19), the Hessian of the Lagrangian for the th iteration is given by the BFGS matrix . The BFGS matrix in each iteration is updated using the BFGS update formula shown in (20). In the first step of the iterations however, the inverse of Hessian of the Lagrangian is taken as the identity matrix () instead of using the following formula:where and are calculated using the following formula:where is calculated to beThe same as the inverse-FORM, the step direction vector () in (3) is calculated using (9). In the calculation of , the values of , , , and are calculated using (10), (11), (12), and (13), respectively.
In the calculation of using (12), is calculated using the following formula, instead of (14), while is calculated unchangingly using (15):In the calculation of in (13), the values of , and are calculated using the following formulae instead of (16) and (17):A pseudocode for this intermediate algorithm is provided in Algorithm 1, in which it is noted that the BFGS update formula is used to update the inverse of Hessian in every iteration. The proposed use of the BFGS update formula increases the computational efficiency of this intermediate algorithm when compared to that of the inverse-FORM because it provides more optimized step changes.
| ||||||||||||||||||||||||||||
The convergence criterion in the equation below is used to stop the iterative loop in Algorithm 1. It was originally proposed for inverse-FORM by Der Kiureghian et al. [11]: where is the vector of design variables () in the th iteration; is its magnitude; is the absolute value of the unknown parameter in the th iteration.
However, the intermediate algorithm is sometimes found to compromise the accuracy of the final solution as demonstrated through the numerical examples in Section 4. This is because the BFGS update formula does not always guarantee a rigorous convergence, and this is represented by fluctuations in the determinant value of the inverse of BFGS matrix through the numerical problems covered in this paper later. This fluctuation or the variation of the step size in each iteration affects the accuracy of the final solution apart from the improvement in the efficiency. To overcome this issue, the next section provides formulae for a BFGS-based hybrid algorithm, which has better accuracy and the stability in convergence by using both the original HLRF algorithm and the modified algorithm with BFGS update formula in a hybrid manner. This algorithm uses the same convergence criterion in (25).
3.2. BFGS-Based Hybrid Algorithm
The inverse-FORM algorithm and the intermediate algorithm mentioned in previous section become identical if the Hessian of the Lagrangian is approximated as the identity matrix in every iteration. By using the BFGS update formula in (20) to calculate the inverse of Hessian of the Lagrangian in the intermediate algorithm, the efficiency of the search is improved, but the final answer in this algorithm does not guarantee the same level of accuracy as that of inverse-FORM. Using the BFGS matrix results in larger step size and hence faster convergence. However, this convergence is less stable compared to the convergence generated by identity matrix, even though identity matrix results in slower convergence.
To show this in detail, the following numerical problem is considered, which is included as Problem a in the next section: the limit state function is given by = . The variables , , , and follow standard normal distribution and are uncorrelated. The starting point is taken to be 0.2 for all the design variables ), and 0.1 for the unknown parameter . The value of is calculated to be 0.3671 in the forward analysis, but we assume that it is unknown in the inverse reliability analysis. The reliability index () corresponding to this value of is 2.0, and it is taken to be the target reliability index () for the inverse reliability analysis.
The iterations for all the problems considered in this paper, including this problem, were stopped using the stopping criteria in (25). To trace the stability of the convergence of the updating process of the inverse of BFGS matrix, the determinant of the inverse of BFGS matrix and the limit state function values are monitored in Table 1. It shows that the determinant of inverse of Hessian is 1.0 in the first iteration as an initial value, and, for the second to sixth iterations, the value stably converges from 1.42274 to 1.0, except for the third iteration. Due to this exception in the third iteration, the value of the limit state function does not converge to 0 in the fourth iteration, and this step impedes the convergence of the overall analysis; this is different from inverse-FORM.
To avoid this, we propose further modifications resulting in a BFGS-based hybrid algorithm, in which the BFGS update formula is used only until the algorithm meets a determinant value that is neither 1.0 nor converging towards 1.0. For the subsequent iterations, the BFGS update formula is neglected, and the inverse of Hessian is fixed as unity. Note that this checking process always starts from the third iteration step, as the second iteration step cannot provide a clear indication on convergence or divergence. This technique is illustrated in Algorithm 2. As shown in Algorithm 2, a variable is used in the BFGS-based hybrid algorithm. This variable represents the condition for checking whether the inverse of Hessian of the Lagrangian being fixed to be the identity matrix or not and whether the BFGS update formula should be further used or not. The variable ’s initial value is zero and remains as zero until the condition for the inverse of Hessian matrix being fixed as the identity matrix is satisfied; then, the value of is changed to one. For all subsequent iterations, the value of is fixed as 1, and the inverse of Hessian is fixed as the identity matrix.
| ||||||||||||||||||||||||||||||||||||||||||||
When we apply this hybrid algorithm to the above-mentioned numerical example, the changes in the determinant of the inverse of Hessian, the logic flow, and the action in each iteration are outlined in Table 2. The table shows that the inverse of Hessian is fixed to be the identity matrix from the third iteration according to the proposed process. By using inverse-FORM, the intermediate algorithm, and the BFGS-based hybrid algorithm, the results for are estimated as 0.3669, 0.3535, and 0.3668, respectively, while the true solution is 0.3671. It is seen that inverse-FORM and the BFGS-based hybrid algorithm show almost the same result but the intermediate algorithm shows a slightly different value. The results for using these three methods are estimated as 2.0002, 2.0136, and 2.0003, respectively, while the true answer is 2.0000. Again, inverse-FORM and BFGS-based hybrid algorithm show almost the same result but the intermediate algorithm shows slightly different value. A number of iterations required by inverse-FORM, the intermediate algorithm, and the BFGS-based hybrid algorithm are 8, 6, and 7, respectively. The computational efficiencies of the intermediate algorithm and the BFGS-based hybrid algorithm are better than that of inverse-FORM. This example illustrated the calculation steps and the comparison of the accuracies and computational efficiencies of the inverse reliability algorithms. Further comprehensive comparisons of the performance of these three methods are provided in the following section through various numerical examples.
4. Numerical Experiments
This section presents the comparisons of the efficiency and accuracies of the three algorithms for a total of 15 numerical problems. In each problem, a different limit state function represented by is considered, where is the vector of design variables: , and represents the unknown parameter. It should be noted that the individual design variables , , , and so forth are scalars, whereas is a vector. The failure region is defined by the following equation:In the inverse reliability analysis problems, a reliability level is given, which is represented by the target reliability index (). The value of the unknown parameter () needs to be determined for the design point, at which and .
The considered problems are selected or modified from the literature or newly constructed in this study. For the remaining of this section, first, the limit state function, the starting points for the design variables (), and the starting point for the unknown parameter () are provided for these problems; second, comparisons of the efficiency and accuracy of the three algorithms for solving the problems are provided in Table 3; third, an extensive analysis of this comparison is presented by analyzing some of the problems.
Problem 1 (from Der Kiureghian et al. [11]). A limit state function is given as = . The variables , , , and follow the standard normal distribution and are uncorrelated. Three different sets of starting points are considered for , , , , and to check if the final results vary depending on the starting points. Three cases 1a, 1b, and 1c consider different starting points.
1a. The starting point is 0.2 for all design variables (, and ) and 0.1 for the unknown parameter . The true solution for the value of is set to be 0.3671. The reliability index () corresponding to this value of is 2.0 from forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
1b. The starting point is 0.3 for all the design variables (, and ) and 0.3 for the unknown parameter . All the other conditions are the same.
1c. The starting point is 0.4 for all the design variables (, and ) and 0.4 for the unknown parameter . All the other conditions are the same.
Problem 2 (modified from Der Kiureghian et al. [11]). A limit state function is given as = . The variables , , , and follow standard normal distribution and are uncorrelated. Three different starting points are considered for , and to check if the final results vary according to different starting points. Three cases 2a, 2b, and 2c consider different starting points.
2a. The starting point is 0.2 for all the design variables (, and ) and 0.1 for the unknown parameter . The solution for is set to be 0.4291. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
2b. The starting point is 0.3 for all the design variables (, and ) and 0.3 for the unknown parameter . All the other conditions are the same.
2c. The starting point is 0.4 for all the design variables (, and ) and 0.4 for the unknown parameter . All the other conditions are the same.
Problem 3 (modified from Grooteman [25]). A limit state function is given as = . The variable follows the standard normal distribution. The starting points considered for and are equally 0. The solution for is set to be 2.08. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 4 (modified from Grooteman [25]). A limit state function is given as . The variables , and follow the standard normal distribution and are uncorrelated. The starting points for , = 1 to 9, and are equally 0. The solution for is set to be 15.2593. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 5 (modified from Grooteman [25]). A limit state function is given as . The variables and are normally distributed with mean values and standard deviations . The variables are uncorrelated. The starting points considered for , , and are , , and 0, respectively. The solution for is set to be 2.5. The reliability index () corresponding to this value of is 2.5 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 6a. A limit state function is given as . The variables and are normally distributed with mean values and and standard deviations and . The variables are uncorrelated. The starting points considered for , , and are , , and 0, respectively. The solution for is set to be 1.3838. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 6b. The limit state function is the same as in Problem a. The variables, their mean values, standard deviations, and starting points are also the same. The variables are correlated with a correlation coefficient of 0.5 between them. The solution for is set to be 1.3838. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 7. A limit state function is given as = . The variables and are normally distributed with mean values and standard deviations . The variables are uncorrelated. The starting points considered for , , and are , , and 0, respectively. The solution for is set to be 2.0. The reliability index () corresponding to this value of is 1.5105 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 8. A limit state function is given as The variables and are normally distributed with mean values and and standard deviations and . The variables are uncorrelated. The starting point considered for , , and are , , and 0, respectively. The solution for is set to be 1.3992. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 9a. A limit state function is given as . The variables and are normally distributed with mean values and standard deviations . The variables are uncorrelated. The starting point considered for is , for is , and for is 0. The solution for is set to be 1.0. The reliability index () corresponding to this value of is 1.677 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 9b. The limit state function is the same as in Problem a. The variables, their mean values, standard deviations, and starting points are also the same. The variables are correlated with a correlation coefficient of 0.5 between them. The solution for is set to be 1.0. The reliability index () corresponding to this value of is 1.4671 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 10. A limit state function is given as . The variables and are normally distributed with mean values and standard deviations . The variables are uncorrelated. The starting points considered for , , and are , , and 0, respectively. The solution for is set to be 6.0. The reliability index () corresponding to this value of is 2.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 11. A limit state function is given as . The variables and are normally distributed with mean values and and standard deviations and . The variables are uncorrelated. The starting points considered for , , and are , , and 0, respectively. The solution for is set to be 2.3584. The reliability index () corresponding to this value of is 1.4 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 12. A limit state function is given as . The variables , , and are normally distributed with mean values and standard deviations . The variables are uncorrelated. The starting points considered for , , , and are , , , and 0, respectively. The solution for is set to be 1.5551. The reliability index () corresponding to this value of is 1.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 13a. A limit state function is given as . The variables , , and are normally distributed with mean values and and standard deviations and . The variables are uncorrelated. The starting points considered for , , , and are , , , and 0, respectively. The solution for is set to be 0.3438. The reliability index () corresponding to this value of is 1.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 13b. The limit state function is the same as in Problem a. The variables, their mean values, standard deviations, and starting points are also the same. The variables are correlated with a correlation coefficient of 0.5 between each pair of variables. The solution for is set to be 0.3438. The reliability index () corresponding to this value of is 0.7901 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 14. A limit state function is given as = . The variables , , and are normally distributed with mean values and and standard deviations , , and . The variables are uncorrelated. The starting points considered for , , , and are , , , and 0, respectively. The solution for is set to be 1.922. The reliability index () corresponding to this value of is 1.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Problem 15. A limit state function is given as = . The variables , , and are normally distributed with mean values , and and standard deviations , and . The variables are uncorrelated. The starting points considered for , , , and are , , , and 0, respectively. The solution for is set to be 1.6941. The reliability index () corresponding to this value of is 1.0 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Table 3 illustrates the comparison of the inverse reliability algorithms (inverse-FORM, the intermediate algorithm, and the BFGS-based hybrid algorithm) for the above problems. In this table, the following values are provided at the solution point:(i)limit state function ;(ii)the unknown parameter ;(iii)the reliability index .These values are presented along with the number of iterations required by the algorithm to arrive at the solution. The numerical values of and presented under the column named true solution represent the values of the limit state function (zero) and reliability index at the design point, estimated from forward reliability analysis using first-order reliability methods (FORM). These values are what we are targeting at. We assume that the value of the parameter is known beforehand in the forward analysis. For this particular value of , the design point and its associated reliability index are estimated.
The number of iterations taken to arrive at the design point is not presented for the forward analysis, as the purpose of presenting Table 3 is to compare the computational efficiencies and accuracies of the inverse reliability algorithms (inverse-FORM, the intermediate algorithm, and the BFGS-based hybrid algorithm) only. To compare their accuracies, the values of and are used as the benchmark values and presented under the column named true solution. The values of and obtained from each of the three inverse reliability algorithms are compared against the benchmark values. It is to be noted that, in Table 3, values less than have been regarded as zero. The value of the target reliability index obtained from the forward analysis is used as the target reliability index for the all the three inverse reliability algorithms. The values of the target reliability index at the final solution point are presented under respective columns of each of the three inverse reliability algorithms.
From the comparison of the three algorithms as shown in Table 3, the following is observed in general:
(i) The intermediate algorithm is computationally more efficient than inverse-FORM as it takes comparatively a smaller number of iterations to solve an inverse reliability problem. The worse efficiency of inverse-FORM is due to the slower progress by using the smaller step size of its search direction vector in every iteration, compared to that of the search direction vector used by the intermediate algorithm. However, inverse-FORM is more accurate than the intermediate algorithm in estimating the solution point, for almost all the examples.
(ii) It is not as much as to the intermediate algorithm but the BFGS-based hybrid algorithm is also more efficient than inverse-FORM. From Table 3, it is observed that the BFGS-based hybrid algorithm is considerably more efficient than inverse-FORM in solving highly nonlinear problems. However, the BFGS-based hybrid algorithm does not compromise on the accuracy of the final solution as the intermediate algorithm does. It can be observed from Table 3 that for most of the examples, the BFGS-based hybrid algorithm is either more accurate than or at least as accurate as inverse-FORM, while having better efficiency in general.
To provide further explanations about the advantages and limitations of the three algorithms, two of the problems considered in Table 3 (Problems and ) have been analyzed as follows.
Further Explanation about Problem 7. Figure 1 illustrates the identity inverse-Hessian matrix for inverse-FORM and the updating processes of the determinant of inverse of BFGS matrix () in the intermediate algorithm and the BFGS-based hybrid algorithm for Problem . The values for inverse-FORM are represented by dot-dash lines with circular markers; those for the intermediate algorithm are represented by solid lines with asterisk markers; and those for the BFGS-based hybrid algorithm are represented by dotted lines with square markers. When inverse-FORM is used, the determinant of the identity inverse-Hessian matrix is one for all iterations, but when the intermediate algorithm is used, the determinant of inverse of BFGS matrix is observed to fluctuate as shown in Figure 1. It starts from one in the first two iterations and increases to 1.2579 in the third iteration, and then to 1.2678 in the fourth iteration. It decreases to 1.0045 in the fifth iteration but again slightly increases to 1.0066 in the sixth iteration. This fluctuation is due to the updating formula used in the intermediate algorithm, and it affects the convergence of the result.
Figure 2 shows the values of the unknown parameter () for the three algorithms. In this figure, the true solution of that needs to be found is represented by dashed lines. It should be noted in this figure that the solution for obtained using the intermediate algorithm is less accurate when compared to that obtained using inverse-FORM. As shown in Figure 2, the final value of is 2.1017, when inverse-BFGS is used, although its true solution is 2.0. However, its final value is 2.0012 when inverse-FORM is used, which is much more accurate. This is because of the fluctuation of the determinant of inverse of BFGS matrix in the intermediate algorithm, due to which the algorithm sometimes arbitrarily meets the convergence criteria and suddenly stops the iteration even when the obtained solution is not close enough to the true solution.
To obtain a balance between accuracy and efficiency, the BFGS-based hybrid algorithm is introduced. As explained before, in this algorithm, when the determinant of inverse of BFGS matrix diverges away from unity, we fix the determinant to unity manually for the subsequent iterations. This process prevents further unnecessary fluctuation of the determinant. In Figure 1, the dotted line and square markers show that the determinant of inverse of BFGS matrix moves to 1.2579 in the third iteration. However, from the fourth iteration onwards, it is manually fixed to unity for all iterations. As a result of this fixation, the BFGS-based hybrid algorithm is still more efficient than inverse-FORM but it does not compromise the accuracy of the final solution, unlike the intermediate algorithm. As shown in Figure 2, it should be noted that the final result is obtained in just seven iterations using the BFGS-based hybrid algorithm, compared to the 17 iterations taken by inverse-FORM. At the same time, it should also be noted that the final value of 2.0003 obtained using the BFGS-based hybrid algorithm is marginally even more accurate than the final value of 2.0012 obtained using inverse-FORM.
Further Explanation about Problem 12. Figure 3 illustrates the identity inverse-Hessian matrix for inverse-FORM and the updating processes of the determinant of inverse of BFGS matrix () based on the intermediate algorithm and the BFGS-based hybrid algorithm for Problem . Similar to the results for Problem , the determinant of inverse of BFGS matrix is observed to fluctuate. It increases from 1 to 1.4487 in the third iteration before it decreases to 1.0022 in the subsequent iterations, and then again it increases to 1.0517 in the sixth iteration. This fluctuation results in larger step size and faster convergence, and the intermediate algorithm takes just six iterations to arrive at the solution compared to the 23 taken by inverse-FORM. However, this fluctuation also decreases the accuracy of the final solution. As shown in Figure 2, the final value of is 1.6530, when the intermediate algorithm is used, although the true solution is 1.5551. However, its final value is 1.5561 when inverse-FORM is used, which is more accurate.
Figure 4 shows the corresponding search values for the unknown parameter (), in the respective iterations. The BFGS-based hybrid algorithm has an optimum balance between efficiency and accuracy. In this algorithm, once the determinant of inverse of BFGS matrix diverges away from unity, it is fixed manually to unity for the subsequent iterations. In Figure 3, the dotted line with square markers shows that the determinant of inverse of BFGS matrix becomes 1.4487 in the third iteration. From the fourth iteration onwards, it starts converging towards the unity (the identity matrix ) as it reaches 1.0222 in the fifth iteration. However, in the sixth iteration, it increases to 1.0517 and starts to diverge from the identity matrix. Hence, it is manually fixed to unity for all the other subsequent iterations. As a result of this fixation, the BFGS-based hybrid algorithm is still more efficient than inverse-FORM but does not compromise the accuracy of the final solution unlike the intermediate algorithm. As shown in Figure 4, the final result is obtained in just 13 iterations using the BFGS-based hybrid algorithm, compared to the 17 iterations taken by inverse-FORM. Moreover, as shown by in Figure 4, the final value is 1.5560 when the BFGS-based hybrid algorithm is used. This value is marginally more accurate than the final value of 1.5561 obtained using inverse-FORM.
It should also be informed that there are cases where all the three algorithms fail to get a solution due to a divergence issue. When the algorithms were applied to few nonlinear problems, they were found to converge to a point that is not on the limit state boundary. In other words, the solution point does not satisfy the condition given by (2c) and hence cannot be deemed as the design point. We observed that all three algorithms failed in the following example problem.
Problem 16. A limit state function is given as . The variables and are lognormally distributed with mean values and 54 and standard deviations and . The variables are uncorrelated. The starting point considered for is , for is , and for is 0. The solution for is set to be 1140. The reliability index () corresponding to this value of is 5.2126 in the forward analysis, and it is taken as the target reliability index () for the inverse reliability analysis.
Inverse-FORM and the intermediate algorithm required just four and two iterations, respectively, to arrive at their final points. However, these final points do not represent the true solution. Figures 5 and 6 show that the final value of obtained using either algorithm is far away from its true solution 1140. In addition, the value of the limit state function () does not converge to zero before the convergence criteria are met by the intermediate algorithm, as shown in Table 4. Moreover, as only two iterations were required to arrive at the solution, the inverse of the Hessian could not be analyzed. Since inverse-FORM and the intermediate algorithm failed to solve the problem, an optimum balance between the two could not be established and the BFGS-based hybrid algorithm cannot improve the intermediate algorithm in such problems. It is important to note that this problem could not be solved by inverse-FORM either. Hence, it is concluded that the inherent limitation of inverse-FORM in solving certain highly nonlinear limit states is reflected in the limitation to solve this problem by the other two proposed methods.
5. Conclusions
An inverse reliability analysis algorithm based on inverse-FORM, using the BFGS update formula is proposed. The performance of this algorithm is compared with that of inverse-FORM through 15 numerical experiments. From the analysis of the numerical experiments, the following is concluded:(1)The Hessian of the Lagrangian in inverse-FORM is approximated as the identity matrix for each iteration. This makes the step size considerably small for all iterations. In other words, the number of iterations needed to attain the final solution increases, and it decreases the computational efficiency.(2)On the other hand, the intermediate algorithm has better efficiency than inverse-FORM by using the BFGS update formula in each iteration. The step size is relatively large for all iterations. However, this algorithm sometimes compromises the accuracy of the final solution, which is shown by the fluctuating values of inverse of Hessian of the Lagrangian near the design point.(3)For an optimum balance between efficiency and accuracy, the BFGS-based hybrid algorithm is proposed to use. In this algorithm, the inverse of BFGS matrix is used as the inverse of Hessian of the Lagrangian as long as it keeps moving towards unity (). However, once it starts to diverge from unity, it is fixed to unity. Hence, few iterations use and few iterations use the BFGS update formula. This algorithm has similar or better accuracy, compared to inverse-FORM, for the example problems considered in Section 4. Moreover, it is more efficient compared to inverse-FORM.(4)For certain highly nonlinear problems, the inverse-FORM algorithm may not achieve convergence. This limitation still applies to the intermediate algorithm and the BFGS-based hybrid algorithm.
Conflicts of Interest
The authors declare that they have no conflicts of interest.
Acknowledgments
The authors wish to acknowledge the help of Gislaine Periçaro at University of the State of Paraná, Brazil, for sending the MATLAB code of the HLRF-BFGS algorithm. This research was supported by the National Natural Science Foundation of China (Grant no. 51650110509).