Journal of Applied Mathematics

Volume 2013 (2013), Article ID 434636, 12 pages

http://dx.doi.org/10.1155/2013/434636

Research Article

Antioptimisation of Trusses Using Two-Level Population-Based Incremental Learning

Phinit Tontragunrat and Sujin Bureerat

Department of Mechanical Engineering, Faculty of Engineering, Khon Kaen University, Khon Kaen 40002, Thailand

Received 14 December 2012; Accepted 18 March 2013

Academic Editor: Xiaojun Wang

Copyright © 2013 Phinit Tontragunrat and Sujin Bureerat. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

Practical optimum design of structures often involves parameters with uncertainties. There have been several ways to deal with such optimisation problems, and one of the approaches is an antioptimisation process. The task is to find the optimum solution of common design variables while simultaneously searching for the worst case scenario of those parameters with uncertainties. This paper proposed a metaheuristic based on population-based incremental learning (PBIL) for solving antioptimisation of trusses. The new algorithm is called two-level PBIL which consists of outer and inner loops. Five antioptimisation problems are posed to test the optimiser performance. The numerical results show that the concept of using PBIL probability vectors for handling the antioptimisation of truss is powerful and effective. The two-level PBIL can be considered a powerful optimiser for antioptimisation of trusses.

1. Introduction

A truss structure is one of the most widely used engineering structures due to its simplicity and low cost for construction and design. Such a structure can be used in many engineering applications such as bridges, roofs, and towers. Throughout its history, a great deal of research work on truss design optimisation has been investigated, for example, [1–6]. The design process can be categorised as topology, shape, and sizing optimisation. The optimisers used for tackling truss design problems could be the methods with and without using function derivatives. Some of the most popular optimisers are evolutionary algorithms (EAs), which can deal with truss design having single or multiple objective functions. Using EAs, although having low convergence rate and lacking of search consistency, is popular and advantageous since they are simple to use and robust and can deal with any kind of design problems particularly truss design with discrete design variables.

Nevertheless, practical design of trusses and other structures often has inevitable difficulties when uncertainties are involved. For example, it is always difficult to define certain applied loads on structures and material properties. This implies that the real world design problem of trusses will include parameters with uncertainties and it becomes reliability-based optimisation. The simplest way to handle this is by adding the factor of safety to structural constraints. Alternatively, multiobjective design problems which minimise cost and maximise a parameter indicating structural reliability (e.g., structural compliance and natural frequency) are posed and solved for a set of the Pareto optimum structures [6–8]. The more popular approach is the use of reliability-based optimisation techniques, which involve probabilistic design constraints. For example, the use of gradient-based optimisers [9] and evolutionary algorithms [10] for this design process has been reported.

Apart from the aforementioned approaches, a simple but effective way to deal with optimisation with uncertainties is to use the so-called antioptimisation [11]. In the antioptimisation process, there are two sets of design variables, common design variables and ones with uncertainties predefined in certain intervals. One optimisation run has two simultaneous tasks. The first task is to find the solution for the interval variables giving the worst case scenario for the structure, while the second task is finding the optimum solution for the common design variables. Optimisers for this propose have been developed, for example, two-species genetic algorithm (GA) [12], and hybrid genetic algorithm (HybridGA) [13]. From the literature, it is found that using such evolutionary algorithms for solving an antioptimisation problem is somewhat time-consuming.

This paper is concerned with developing a metaheuristic (MH) for tackling antioptimisation of trusses. The work focuses on the metaheuristic because it can deal with discrete design variables which are usually employed in real-world truss design. Population-based incremental learning (PBIL) is chosen and adapted to deal with truss antioptimisation leading to five variants of PBIL. The five methods and HybridGA are then implemented on five antioptimisation problems of 2D trusses. Optimum results show that PBIL is a powerful optimiser for truss antioptimisation and it is superior to HybridGA.

2. Antioptimisation Problem

A typical single-objective truss optimisation is mass minimisation subject to structural design constraints, which can be expressed as

where is a vector sized of common design variables, is structural mass, and are inequality constraints for safety requirements. When variables with uncertainties are included, the problem can be written as

where is a vector sized of variables with uncertainty having lower and upper bounds as and , respectively.

For truss antioptimisation, the problem (2) is separated into two subproblems as the design problem (1) for searching for optimum design variables and the design problem for finding the worst case of a structure written as

where is a function indicating the maximum violation of structural constraints. For simplicity, can be defined as

with the design point being unchanged.

A traditional strategy for solving an antioptimisation problem is to use a two-level approach. The search process starts with initial solutions for and . In one iteration, the method searches for the optimum solution of based on the problem (1) by fixing the value of . Then, use the updated values of for finding the worst solution of based on the problem (3). The process is repeated until the termination conditions are fulfilled.

3. PBIL for Antioptimisation

Over the years, there have been a significant number of metaheuristic algorithms developed for a wide variety of real-world applications, for example, [14–18]. PBIL is chosen for this work because it is a simple but powerful MH and suits well with the concept of antioptimisation. PBIL was first proposed by Baluja in 1994 [19]. The method is based upon a simple estimation of distribution algorithm and searches for an optimum using binary strings. Unlike GA which keeps a set of binary design solutions (better known as a population), PBIL uses the so-called probability vector to represent a binary population. Figure 1 shows some probability row vectors which will be used to produce binary population matrices where one row of the matrix represents a binary design solution. The element of the vector determines the probability of having the string “1” on the th column of the binary population. From the figure, it can be seen that one probability vector can produce various binary populations. As the optimisation proceeds, the probability vector is updated iteratively leading to an optimum solution. A typical computational procedure of PBIL is given in Algorithm 1. Initially, the probability vector is set as . Then, the corresponding population is generated where the best binary solution is found. The probability vector is then updated based upon the best solution as

where is the th element of the probability vector from the previous iteration, is the updated th element of the probability vector, and is the th element of the best binary solution. is called a learning rate which herein is set to be a uniform random number in the range of generated anew when the probability vector update takes place. In this work, mutation is not used to modify the probability vector, but the value of after being updated will be set to the range of (if the updated value of is lower than 0.1 or higher than 0.9, it will be set as 0.1 and 0.9, resp.) in order to prevent a premature convergence.

Initialisation ,  ,   

Main procedure

(1) Generate a binary population B according to .

(2) Perform function evaluations and find the best

solution b from .

(3) Update using (5).

(4) Set to in cases that it is out of the interval.

(5) If the termination condition is met, stop the procedure;

otherwise, set and go to (1).

Algorithm 1: Population-based incremental learning.

Figure 1: Probability vectors and their corresponding populations.

When dealing with an antioptimisation problem, the method is modified as shown in Algorithm 2. As it involves two levels of optimisation search, the developed PBIL will be named two-level population-based incremental learning. The algorithm starts with generating an initial binary population where each binary solution contains strings for design variables and variables with uncertainties . Then, the best binary solution containing two parts as for and for is found based on the design problem (1). On the other hand, the worst binary solution is obtained based on the problem (3). The method uses two probability vectors as and for representing binary populations of and , respectively. Afterwards, a set of binary design solutions for (denoted as ) are created based on , while each solution in the population has its second part of a binary string for as . The new best solution is obtained from sorting the current population and the best solution from the previous iteration. The probability vector is updated using the first part of the new best solution . This is the first level of the process which is said to be outer loops.

Initialisation ,  , and find and from an initial population.

Main procedure

(1) For to (outer loop)

(2) Generate a binary population according to and assign as the second part of every solution in . The population is

.

(3) Perform function evaluations .

(4) Find the new best solution b from based on the objective function in (1).

(5) Update with using (5).

(6) Set to in cases that it is out of the interval.

(7) For to (inner loop)

        (8) Generate a binary population according to and assign as the first part of every solution in . The population

        is .

        (9) Perform function evaluations

        (10) Find the new worst solution w from based on the objective function in (3).

        (11) Update with using (5).

        (12) Set to in cases that it is out of the interval.

(13) Next

(14) Next

Algorithm 2: Population-based incremental learning for antioptimisation.

For inner loops (steps (7)–(13)) which are the search for the worst case scenario, a set of binary solutions for (denoted as ) is generated from the probability vector where each solution has the first part of a binary string for as which is the first part of the current worst solution. The new worst solution is then obtained based on the problem (3) by sorting the current population and the previous worst solution. The probability is updated by using , the second part of . The inner loop procedure is stopped after loops. Similarly, the outer loop search is terminated after loops. This implies that if the population size for both inner and outer loops is , the total number of function evaluations for each simulation run is . It should be noted that we use the worst solution for finding the worst case structures because it is expected to give the worst objective function values which may help accelerate PBIL to the worst case. In the case studies, we will examine the use of best and worst solutions for searching the worst case scenario.

4. Truss Design Case Studies

Five antioptimisation problems (AOPs) of three truss structures will be used to test the proposed algorithms. The first truss is called a 2-bar truss shown in Figure 2. The structure is subject to a vertical load with uncertainty at node 3. The second structure is named a 10-bar truss [20] shown in Figure 3. The structure consists of 6 nodes and 10 bars where nodes 1 and 2 are fixed and nodes 4 and 6 are subject to external forces and , respectively. The third structure is called a 25-bar truss as displayed in Figure 3. The truss has 12 nodes and 25 bars where nodes 1 and 12 are fixed. The structure is applied by loads , , , , and at nodes 2, 4, 6, 8, and 10, respectively. The design problems can be detailed as follows.

Figure 2: 2-bar truss.

Figure 3: 10-bar truss.

AOP1: Optimisation of the 2-Bar Truss. The design problem can be written as:

where is the cross-sectional area of the th bar element. is the maximum stress on truss elements. is the axial load acting on the th element, while is the critical buckling load for the element. The structures for all 5 test problems are made up of material with the Young modulus  N/m², yield stress  N/m², and density  kg/m³. The common design variables are shape and sizing variables. The external force is set to be variables with uncertainties. The task is to find the external force that gives the worst case scenario for the structure while simultaneously trying to perform mass minimisation.

AOP2: Sizing Optimisation of the 10-Bar Truss. The second design problem can be written as:

where is the diameter of the th bar element. is the maximum -direction displacement of the structure. The common design variables are set to be discrete so that it is close to a practical truss design process. The external forces and are set to be variables with uncertainties. The task is to find the external forces that give the worst case scenario for the structure while, at the same time, trying to perform mass minimisation with sizing design variables.

AOP3: Sizing Optimisation of the 25-Bar Truss. The design problem can be written as:

In this case, there are uncertainties in applied loads and material property. The sizing design variables are set to have a symmetric structure. Thus, we have

(i) for ,(ii) for and ,(iii) for and ,(iv) for and ,(v) for and ,(vi) for and ,(vii) for and ,(viii) for and ,(ix) for and ,(x) for and ,(xi) for and ,(xii) for and ,(xiii) for and .

AOP4: Shape and Sizing Optimisation of the 10-Bar Truss. The fourth design problem is the same problem as AOP2 with additional 4 shape design variables for . The shape variables determine the positions of nodes 3 and 5 in both and directions. The design variables are used to modify the original positions (shown in Figure 3) of nodes 3 and 5. The bound constraints are set as for .

AOP5: Shape and Sizing Optimisation of the 25-Bar Truss. The fifth design problem is the same problem as AOP2 with additional 3 shape design variables for . The shape variables determine the -direction positions of nodes 3, 5, 7, 9, and 11, where is set for the positions of nodes 3 and 11, is set for the positions of nodes 5 and 9, and is set for the positions of node 7. The design variables are used to modify the original positions (shown in Figure 4) of those nodes. The bound constraints are set as for .

Figure 4: 25-bar truss.

By defining a few set of design parameter settings, various versions of PBIL can be obtained as follows.

(i)PBILb5: this optimiser uses from the best solution instead of from the worst solution in step (8) of Algorithm 2. is set to be 5. (ii)PBILw5: this is PBIL detailed in Algorithm 2, where is set to be 5. (iii)PBILw5m: this is PBILw5 with GA mutation. Having generated binary populations in steps (2) and (8), The GA mutation is applied to the populations, where each solution has the probability of being mutated as 0.25. (iv)PBILw1: this is PBIL detailed in Algorithm 2, where is set to be 1.(v)PBILw10: this is PBIL detailed in Algorithm 2, where is set to be 10.

For AOP1, the population size is set to be 40, whereas the total number of function evaluations for stopping the search procedure is 2,400. For other design problems, the population size is set to be 100, whereas the total number of function evaluations for stopping the search procedure is 15,000. PBIL with various values is set to examine the effect of the inner and outer loops on the search performance. The GA mutation is employed under the assumption that it may help improving PBIL convergence rate. Each optimiser is used to solve the antioptimisation problems 30 runs. Since PBIL cannot deal with design constraints directly, the penalty function technique based on the fuzzy set theory [21] is employed. It should be noted that we have tested using several penalty function techniques earlier, and the fuzzy set theory gives the best results. The metaheuristics employed do not have reliable termination criterion, therefore, their search will be stopped based on the maximum number of function evaluations.

Furthermore, in order to verify the performance of the proposed algorithms, an existing evolutionary algorithm for antioptimisation called a hybrid genetic algorithm [13] will be employed to solve the test problems and compared with the various PBILs. For this performance test, HybridGA uses real codes for design variables. The method of Hooke and Jeeves is used for searching the worst case. The number of good solutions taken for mutation is set to be 10. The roulette wheel selection method is used to select design solutions for crossover operation. The optimiser is terminated when the maximum number of function evaluations set for PBILs in the previous paragraph is reached.

5. Optimum Results

The optimum results of AOP1 are given in Table 1. Figure 5 displays the contour of the objective function and the boundaries of buckling constraints with . It should be noted that the stress constraints do not affect the feasible region for this design case. From the figure, it is seen that the buckling constraint where  N gives the most narrow feasible region and therefore leads to the worst case results. The optimum for the worst case scenario is and  N. According to the results obtained from the various optimisers, HybridGA cannot capture the worst case for all runs, while PBILs can find the worst case for some optimisation runs. The best solutions obtained by using five versions of PBIL are the same, that is, and  N, which can be classified as a near optimum of the design problem. Based on the worst cases being explored, PBILw10 gives the best results, while the second best is PBILw1.

Table 1: Optimum results of AOP1.

MHs
HybridGA
PBILb5
PBILw5
PBILw5m
PBILw1
PBILw10

Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev

0.5048
0.0242
0.5613
0.1011
0.6247
0.1176
0.6333
0.1587
0.6344
0.1558
0.5914
0.1302

0.0029
0.0001
0.0038
0.0003
0.0037
0.0004
0.0038
0.0005
0.0038
0.0004
0.0038
0.0004

200.0000
0.0000
399.1398
130.0818
370.3226
142.7784
400.8602
164.3949
405.1613
157.4620
424.0860
151.7861

49.9355
1.6789
67.2216
4.8174
68.2111
5.5543
70.2185
5.9409
69.9382
4.6033
69.4287
5.3346

max

0.0000

Figure 5: Optimum of AOP1.

The optimum results of AOP2 obtained from the various optimisers are given in Table 2. For this design problem, it is obvious that the worst possible case for the 10-bar truss is when . From the results, it can be seen that HybridGA and PBILb5 fail to explore the worst case, while other optimiser which are based on using in step (8) of Algorithm 2 can find the worst case for almost every optimisation run. According to the mean value of objective function from 30 runs, PBILw1 gives the best results. However, it is found that PBILw1 cannot find the worst case for all 30 runs, although the values are not significant. This is due to the lower number of inner loops used to explore the worst case. In contrast, PBILw10 gives the worst results among PBILw variants because it spends less time in searching for the optimum mass. By comparing between PBILw5 and PBILw5m, the GA mutation gives insignificant improvement for PBIL.

Table 2: Optimum results of AOP2.

MHs
HybridGA
PBILb5
PBILw5
PBILw5m
PBILw1
PBILw10

Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev

0.0453
0.0073
0.0500
0.0000
0.0500
0.0000
0.0500
0.0000
0.0500
0.0000
0.0503
0.0018

0.0463
0.0096
0.0493
0.0025
0.0500
0.0026
0.0497
0.0032
0.0477
0.0043
0.0543
0.0063

0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0807
0.0025

0.0610
0.0040
0.0603
0.0018
0.0600
0.0000
0.0603
0.0018
0.0600
0.0000
0.0650
0.0068

0.0500
0.0087
0.0493
0.0025
0.0500
0.0026
0.0500
0.0000
0.0477
0.0043
0.0520
0.0041

0.0607
0.0025
0.0613
0.0051
0.0610
0.0040
0.0607
0.0025
0.0600
0.0000
0.0627
0.0064

0.0810
0.0031
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0803
0.0018

0.0517
0.0099
0.0503
0.0018
0.0500
0.0000
0.0500
0.0000
0.0500
0.0000
0.0517
0.0038

0.0427
0.0052
0.0493
0.0025
0.0500
0.0000
0.0500
0.0000
0.0483
0.0038
0.0493
0.0025

0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0800
0.0000
0.0803
0.0018

74.7849
1.1783
77.5938
1.1768
80.0000
0.0000
80.0000
0.0000
80.0000
0.0000
80.0000
0.0000

171.5082
13.5158
165.3552
7.5152
175.0000
0.0000
175.0000
0.0000
174.9984
0.0089
175.0000
0.0000

558.7238
30.9474
567.8900
9.9080
568.7844
7.3917
568.2535
6.2552
559.2016
7.1018
594.2857
20.6724

max

0.0000

The optimum results of AOP3 obtained from the various PBILs are given in Table 3. The worst case is . Similar conclusions as with the AOP2 case can be drawn except that PBILw5 is slightly better than PBILw5m. Table 4 shows the results of AOP4. Similar to the first two cases, HybridGA and PBILb5 fail to explore the worst case scenario, while, for this case, all the versions of PBILw can capture the worst case for all runs. PBILw1 gives the best results, while the worst among PBILw versions is PBILw10. For the fifth design case as shown in Table 5, PBILw optimisers can capture the worst case scenario for almost 30 runs, while PBILb5 and HybridGA fail to find out the worst case solutions. The best optimiser is PBILw1 whereas PBILw5m is slightly better than PBILw5.

Table 3: Optimum results of AOP3.

MHs
HybridGA
PBILb5
PBILw5
PBILw5m
PBILw1
PBILw10

Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev

0.0667
0.0106
0.0753
0.0078
0.0707
0.0037
0.0810
0.0243
0.0697
0.0032
0.0817
0.0172

0.1017
0.0091
0.1533
0.0127
0.1550
0.0201
0.1483
0.0207
0.1500
0.0000
0.1600
0.0242

0.0800
0.0037
0.0820
0.0076
0.0847
0.0073
0.0850
0.0078
0.0817
0.0046
0.0883
0.0079

0.0690
0.0109
0.0727
0.0052
0.0750
0.0078
0.0747
0.0082
0.0700
0.0037
0.0800
0.0164

0.0690
0.0109
0.0770
0.0160
0.0770
0.0084
0.0843
0.0355
0.0750
0.0051
0.0867
0.0121

0.0660
0.0104
0.0690
0.0061
0.0713
0.0035
0.0737
0.0156
0.0687
0.0043
0.0750
0.0073

0.1000
0.0000
0.1283
0.0252
0.1500
0.0131
0.1517
0.0207
0.1500
0.0000
0.1500
0.0186

0.0923
0.0043
0.1027
0.0131
0.0997
0.0018
0.1053
0.0229
0.0993
0.0025
0.1050
0.0185

0.0680
0.0092
0.0730
0.0065
0.0727
0.0069
0.0767
0.0103
0.0720
0.0081
0.0843
0.0155

0.0680
0.0096
0.0750
0.0078
0.0760
0.0097
0.0793
0.0083
0.0710
0.0031
0.0827
0.0108

0.0657
0.0068
0.0770
0.0099
0.0727
0.0074
0.0770
0.0158
0.0697
0.0032
0.0820
0.0167

0.1500
0.0000
0.1500
0.0000
0.1517
0.0091
0.1517
0.0091
0.1500
0.0000
0.1583
0.0190

0.0777
0.0057
0.0847
0.0090
0.0873
0.0078
0.0907
0.0087
0.0840
0.0056
0.0913
0.0221

150.0000
0.0000
279.9365
13.8161
297.8886
11.5648
293.5239
21.5257
300.0000
0.0000
299.7019
1.6330

150.0000
0.0000
278.6706
15.4757
296.4614
19.3818
289.2913
33.1890
300.0000
0.0000
298.5484
7.9508

150.0000
0.0000
252.3558
33.5946
297.3412
14.5631
289.8240
31.2534
300.0000
0.0000
297.0088
16.3835

4751.2034
230.5610
5974.5867
363.5549
6222.8573
456.2727
6566.8994
1086.3438
5912.7947
92.7879
7045.4299
1006.9112

max

Table 4: Optimum results of AOP4.

MHs
HybridGA
PBILb5
PBILw5
PBILw5m
PBILw1
PBILw10

Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev

0.0467
0.0084
0.0517
0.0053
0.0520
0.0041
0.0513
0.0043
0.0490
0.0031
0.0533
0.0084

0.0477
0.0107
0.0510
0.0040
0.0503
0.0018
0.0513
0.0035
0.0507
0.0045
0.0543
0.0082

0.0833
0.0048
0.0867
0.0055
0.0863
0.0067
0.0867
0.0048
0.0860
0.0050
0.0873
0.0069

0.0603
0.0049
0.0577
0.0082
0.0607
0.0098
0.0577
0.0068
0.0563
0.0076
0.0610
0.0099

0.0570
0.0070
0.0543
0.0068
0.0590
0.0092
0.0533
0.0071
0.0553
0.0078
0.0583
0.0105

0.0613
0.0043
0.0603
0.0072
0.0617
0.0079
0.0603
0.0093
0.0577
0.0043
0.0653
0.0107

0.0720
0.0130
0.0783
0.0046
0.0773
0.0058
0.0797
0.0056
0.0760
0.0081
0.0793
0.0087

0.0457
0.0082
0.0507
0.0037
0.0500
0.0037
0.0507
0.0037
0.0490
0.0031
0.0523
0.0082

0.0440
0.0056
0.0510
0.0031
0.0507
0.0025
0.0497
0.0032
0.0483
0.0038
0.0507
0.0045

0.0787
0.0035
0.0787
0.0051
0.0797
0.0041
0.0770
0.0047
0.0780
0.0048
0.0810
0.0055

0.0518
0.1773
0.3132
0.2705
0.1478
0.3773
0.3319
0.3448
0.2337
0.3527
0.2345
0.4409

0.5991
0.1766
0.5610
0.1850
0.6211
0.1079
0.5072
0.2017
0.6345
0.1444
0.5174
0.1896

0.2160

0.6804
0.1490
0.5697
0.1723
0.5550
0.1935
0.5924
0.1489
0.6494
0.1410
0.5549
0.1754

75.3793
1.2182
78.1703
1.5065
80.0000
0.0000
80.0000
0.0000
80.0000
0.0000
80.0000
0.0000

170.9637
7.2167
166.1746
7.4693
175.0000
0.0000
175.0000
0.0000
175.0000
0.0000
175.0000
0.0000

479.4000
34.7275
529.8728
21.6285
535.8320
21.6881
534.5283
22.3252
501.9159
11.7035
574.2029
37.1328

max

0.0000

Table 5: Optimum results of AOP5.

MHs
HybridGA
PBILb5
PBILw5
PBILw5m
PBILw1
PBILw10

Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev
Avrg
Stdev

0.0787
0.0157
0.0787
0.0082
0.0813
0.0111
0.0800
0.0105
0.0730
0.0065
0.0870
0.0115

0.1233
0.0286
0.1533
0.0127
0.1483
0.0091
0.1500
0.0131
0.1500
0.0000
0.1577
0.0311

0.0830
0.0174
0.0780
0.0119
0.0833
0.0175
0.0810
0.0171
0.0717
0.0087
0.0903
0.0227

0.0770
0.0124
0.0810
0.0212
0.0787
0.0111
0.0747
0.0104
0.0727
0.0087
0.0883
0.0261

0.0807
0.0141
0.0770
0.0079
0.0803
0.0096
0.0803
0.0110
0.0717
0.0065
0.0847
0.0117

0.0793
0.0131
0.0740
0.0062
0.0783
0.0099
0.0770
0.0088
0.0710
0.0031
0.0857
0.0205

0.1200
0.0249
0.1483
0.0091
0.1533
0.0183
0.1567
0.0217
0.1517
0.0091
0.1557
0.0310

0.0893
0.0187
0.0857
0.0176
0.0840
0.0214
0.0840
0.0181
0.0750
0.0107
0.0963
0.0318

0.0780
0.0140
0.0807
0.0098
0.0827
0.0120
0.0777
0.0094
0.0747
0.0094
0.0833
0.0163

0.0810
0.0106
0.0783
0.0095
0.0783
0.0105
0.0777
0.0101
0.0713
0.0035
0.0817
0.0162

0.0817
0.0109
0.0773
0.0098
0.0823
0.0205
0.0767
0.0152
0.0707
0.0052
0.0850
0.0242

0.1500
0.0000
0.1533
0.0127
0.1500
0.0000
0.1500
0.0000
0.1500
0.0000
0.1540
0.0234

0.0857
0.0161
0.0823
0.0168
0.0860
0.0203
0.0823
0.0165
0.0737
0.0089
0.0940
0.0302

0.8037

0.7962

0.7824

0.9604

0.7010

1.0779

0.7655

1.0364

1.0393

0.9608

0.9619

1.3451

0.7922

1.1555

1.1576

1.0618

0.9760

1.3226

194.0161
59.2515
238.8221
48.0552
300.0000
0.0000
300.0000
0.0000
300.0000
0.0000
299.5406
2.5164

168.5592
35.6225
251.6178
31.7033
300.0000
0.0000
300.0000
0.0000
300.0000
0.0000
296.8964
16.9992

239.6624
57.7826
231.6178
47.0528
300.0000
0.0000
300.0000
0.0000
300.0000
0.0000
299.4868
2.8109

5222.3215
813.5479
5440.5355
524.4721
5616.7374
429.4775
5679.4132
654.9014
4938.2933
266.2513
6585.0710
1474.1376

max

0.0000

0.0000

0.0000

0.0000

0.0000
68.9978
377.9440

Based on the standard deviation, the variants of PBILw are rather consistent. From the constraint violation values in Tables 1–5, it can be said that the fuzzy set theory is efficient and effective for constrained truss design. Table 6 shows the total number of worst cases captured by the optimisers having solved the design problems for 30 runs. It can be seen that PBILw is effective for exploring the worst case scenarios for AOP2-5. PBILw10 fails to capture the worst case once for AOP3 and AOP5, although it spends more time to search for the worst case scenario. This can possibly be due to a premature convergence of the algorithm. For the first design problem, all the optimisers have more difficulty to search for the worst case.

Table 6: Number of worst cases found by the optimisers.

MHs
AOP1
AOP2
AOP3
AOP4
AOP5

HybridGA
0
0
0
0
0

PBILb5
1
0
0
0
0

PBILw5
5
30
29
30
30

PBILw5m
8
30
27
30
30

PBILw1
8
29
24
30
30

PBILw10
9
30
29
30
29

The best structures obtained from running PBILw5, PBILw5m, PBILw1, and PBILw10 for AOP2, AOP3, AOP4, and AOP5 are illustrated in Figures 6, 7, 8, and 9, respectively. The structures obtained from the 4 optimisers for each design case are rather similar in size and shape to each other. In cases of the design problems AOP2-5, with 15,000 function evaluations and population size of 100, PBILw1 has a number of outer loops as loops, while PBILw5 and PBILw10 have only 25 and 14 loops, respectively. In the test problems, the number of inner loops is adequate to search for the worst cases for all design cases; thus, PBILw1 which spends more time to search for the optimum solution of gives the best results for all design cases. In order to use the proposed PBIL for antioptimisation of other engineering systems, predefining the proper value of is important since it can affect the search performance. This relies on several factors such as the size of variables and . The hybrid genetic algorithm, on the other hand, is not efficient for the truss design problems. However, optimisation parameter settings can affect its search performance.

(a)

(b)

(c)

(d)

Figure 6: Optimum structures of AOP2 from various optimisers.

(a)

(b)

(c)

(d)

Figure 7: Optimum structures of AOP3 from various optimisers.

(a)

(b)

(c)

(d)

Figure 8: Optimum structures of AOP4 from various optimisers.

(a)

(b)

(c)

(d)

Figure 9: Optimum structures of AOP5 from various optimisers.

6. Conclusions and Discussion

A metaheuristic based on PBIL for antioptimisation of trusses is developed, and it is termed two-level PBIL. The method consists of two levels for two searching tasks. The first level is an outer loop used to explore the optimum of common design variables, while the inner loop is used to find the worst case scenario of the variables with uncertainties. It is shown that when searching for the worst case, the function evaluation based on the current worst solution gives better search results than using the current best solution. The GA mutation applied to a binary population of PBIL does not have significantly impact on PBILw search performance. The results show that the proposed PBILw is an efficient optimiser for tackling a truss antioptimisation problem. Moreover, it is superior to the hybridGA. The performance of PBILw, to a great extent, relies on the predefined number of inner loops for searching the worst case. It can be concluded that the concept of using probability vectors to represent binary populations in PBIL is powerful for dealing with antioptimisation. For future work, the hybrid approach of PBIL will be studied. Also, the applications of the two-level PBIL will be employed to tackle other antioptimisation problems.

Acknowledgments

The authors are grateful for the support from The Royal Golden Jubilee Ph. D. Program (Grant no. PHD/0145/2553) and the Thailand Research Fund (Grant no. BRG5580017).

References

A. Kaveh and S. Talatahari, “Particle swarm optimizer, ant colony strategy and harmony search scheme hybridized for optimization of truss structures,” Computers and Structures, vol. 87, no. 5-6, pp. 267–283, 2009.

P. B. Thanedar, J. S. Arora, C. H. Tseng, O. K. Lim, and G. J. Park, “Performance of some SQP algorithms on structural design problems,” International Journal for Numerical Methods in Engineering, vol. 23, no. 12, pp. 2187–2203, 1986.

A. Kaveh and S. Talatahari, “Particle swarm optimizer, ant colony strategy and harmony search scheme hybridized for optimization of truss structures,” Computers and Structures, vol. 87, no. 5-6, pp. 267–283, 2009.

H. M. Gomes, “Truss optimization with dynamic constraints using a particle swarm algorithm,” Expert Systems with Applications, vol. 38, no. 1, pp. 957–968, 2011.

W. A. Bennage and A. K. Dhingra, “Single and multiobjective structural optimization in discrete-continuous variables using simulated annealing,” International Journal for Numerical Methods in Engineering, vol. 38, no. 16, pp. 2753–2773, 1995.

N. Pholdee and S. Bureerat, “Performance enhancement of multiobjective evolutionary optimizers for truss design using an approximate gradient,” Computers and Structures, vol. 106-107, pp. 115–124, 2012.

C. Noilublao and S. Bureerat, “Topology and sizing optimization of trusses with adaptive ground finite elements using multiobjective PBIL,” Advanced Materials Research, vol. 308–310, pp. 1116–1121, 2011.

N. Noilublao and S. Bureerat, “Simultaneous topology, shape and sizing optimisation of a three-dimensional slender truss tower using multiobjective evolutionary algorithms,” Computers and Structures, vol. 89, pp. 2531–2538, 2011.

B. M. Adams, M. S. Eldred, and J. W. Wittwer, “Reliability-based design optimization for shape design of compliant micro-electro-mechanical systems,” in Proceedings of the 11th AIAA/ISSMO Multidisciplinary Analysis and Optimization Conference, pp. 1042–1056, AIAA, September 2006.

K. Deb, S. Gupta, D. Daum, J. Branke, A. K. Mall, and D. Padmanabhan, “Reliability-based optimization using evolutionary algorithms,” IEEE Transactions on Evolutionary Computation, vol. 13, no. 5, pp. 1054–1074, 2009.

M. Lombardi and R. T. Haftka, “Anti-optimization technique for structural design under load uncertainties,” Computer Methods in Applied Mechanics and Engineering, vol. 157, no. 1-2, pp. 19–31, 1998.

G. Venter and R. T. Haftka, “Two-species genetic algorithm for design under worst case conditions,” Evolutionary Optimization, vol. 2, no. 1, pp. 1–19, 2000.

N. Wang and Y. Yang, “Optimization of structures under load uncertainties based on hybrid genetic algorithm,” in Evolutionary Computation, W. P. dos Santos, Ed., pp. 321–340, I-Tech, Vienna, Austria, 2009.

A. R. Yıldız, “A novel hybrid immune algorithm for global optimization in design and manufacturing,” Robotics and Computer-Integrated Manufacturing, vol. 25, no. 2, pp. 261–270, 2009.

I. Durgun and A. R. Yıldız, “Structural design optimization of vehicle components using cuckoo search algorithm,” Materials Testing, vol. 54, no. 3, pp. 185–188, 2012.

S. L. Tilahun and H. C. Ong, “Modified firefly algorithm,” Journal of Applied Mathematics, vol. 2012, Article ID 467631, 12 pages, 2012.

X. Cai, S. Fan, and Y. Tan, “Light responsive curve selection for photosynthesis operator of APOA,” International Journal of Bio-Inspired Computation, vol. 4, no. 6, pp. 373–379, 2012.

Z. Cui, F. Gao, Z. Cui, and J. Qu, “A second nearest-neighbor embedded atom method interatomic potential for Li-Si Alloys,” Journal of Power Sources, vol. 207, p. 150, 2012.

S. Baluja, “Population-based incremental learning: a method for integrating genetic search based function optimization and competitive learning,” Tech. Rep. CMU_CS_95_163, Carnegie Mellon University, 1994.

Z. Qiu and X. Wang, “Structural anti-optimization with interval design parameters,” Structural and Multidisciplinary Optimization, vol. 41, no. 3, pp. 397–406, 2010.

F. Y. Cheng and D. Li, “Fuzzy set theory with genetic algorithm in constrained structural optimization,” in Proceedings of the 1st US-Japan Joint Seminar on Structural Optimization, pp. 55–66, Advances in Structural optimization, April 1997.