Transcript dakota-2
Introduction
Optimum Design Process
Mathematical process of finding the conditions that give maximum or minimum value of a function Identify : (1) Design variables (2) Objective functions to be minimized/maximized (3) Constraints that must be satisfied Initial design Analyze the system Convergence criteria ?
N Change design using Optimization technique Y Optimum Design
Introduction …
Applications
Optimization is at work everywhere: manufacturing, transportation, logistics, financial services, utilities, energy, telecommunications, government, defense and retail
Engineering Applications
Vehicle design and analysis Shape optimization of Aircraft structures Heat transfer analysis in CVD reactors Size and topology optimization of mechanical components
Medical Applications
Algorithms for new drug development Protein structure assessment DNA sequence mapping
Environmental protection
Efficient soil and water resource utilization Land and natural resource allocation
Management Mathematics
Supply Chain Management, Distribution Management and Production Scheduling
Background Information
Optimization Software Packages available in the Industry
DAKOTA – Sandia National Labs, a complete optimization toolkit iSIGHT* - Engineous Software Inc, a complete optimization toolkit GENESIS* - Vanderplaats Research & Development, Inc., Structural Analysis and Optimization Software Mathematical Dynamic Modeling (MADYMO)* – TNO Automotive Hierarchical Evolutionary Engineering Design System (HEEDS)* – Red Cedar Technology OPTIMUS* – Noesis Solutions, Optimization software LS-OPT* - Livermore Software Technology Corporation COSMOSWorks™ and COSMOSM™* - Structural Research & Analysis Corporation MATLAB Optimization Toolbox* – MathWorks * Commericial packages
Background Information
Obtaining DAKOTA
DAKOTA binary executable files and source code files are available through the following website:
http://endo.sandia.gov/DAKOTA Installing DAKOTA - Binary Executable Files gunzip Dakota_4_x.OSversion.tar.gz
tar -xvf Dakota_4_x.OSversion.tar
Running DAKOTA dakota -i dakota.in
dakota -i dakota.in > dakota.out dakota –i dakota.in –read_restart dakota.rst > dakota.out
Multiprocessor Execution mpirun –np 4 dakota –i dakota.in > dakota.out mpirun –machinefile machines –np 4 dakota –i dakota.in > dakota.out
Optimization with DAKOTA
Design Analysis Kit for Optimization and Terascale Applications (DAKOTA)
Software toolkit which provides a flexible and extensible interface between simulation codes and iterative analysis methods Improved or optimal designs using state-of-the-art optimization methods Shortens design cycle and reduces overall product development costs
Black-Box interface between DAKOTA and a user-supplied simulation code
Multidimensional Vector
Parameter Study
LHS DDACE Centered List Pseudo Monte Carlo Modern DOE Classical DOE CCD
Capabilities of DAKOTA
Sampling Methods and DOE Uncertainty Quantification Optimization Software packages Optimization Strategies
Analytic Reliability method Stochastic FE method
CONMIN
Multilevel Hybrid
Surface Fitting methods
First-order Taylor Series
Parallel Computing
AMV SGOPT Multistart Local Quadratic Polynomial AMV+ PICO Pareto Kriging Interpolation FORM APPS MINLP ANN SORM LHS Box Behnken OPT++ OUU MARS Orthogonal Array sampling NPSOL* SBO LHS : Latin Hypercube sampling DDACE : Distributed Design and Analysis for Computer Experiments DOE : Design of Experiments CCD : Central Composite Design AMV : Advanced Mean-Value methods FORM/SORM : First/Second Order Reliability Method MINLP : Mixed Integer Nonlinear Programming OUU : Optimization Under Uncertainty SBO : Surrogate Based Optimization ANN : Artificial Neural Network MARS : Multivariate Adaptive Regression Splines DOT*
Flexibility in DAKOTA
Files required for Simulation
DAKOTA Input File e.g., Dakota_rosenbrock.in
Simulation Driver Script File e.g., simulator_script Pre-Processing Utility e.g., transfer_perl Template Simulation Input file e.g., ros.template
Adapting the Scripts for another Simulation
Steps for this purpose are
Create a template simulator input file by identifying the fields in an existing input file.
Modify the Perl variables in the perl script file. Modify the analysis section of simulator script file. Change the post-processing section in simulator_script to reflect the revised extraction process. Modify the DAKOTA input file to define the initial values, bounds, and tags in the variables specification and the number of objectives and constraints in the responses specification.
Capabilities …
Optimization studies have shown that there is no single optimization technique that works best for all design problems. A combination of techniques can provide the best opportunity for finding an optimal solution
Optimization Strategies Flow chart of SBO
Multilevel Hybrid Different optimization algorithms at different stages Multistart Local Multiple local optima exists
DACE (data sampling)
Select design points that must be analyzed Pareto optimization Multiple sets of weights Sampling Based
Simulation
Analyze system using computational methods Optimization under Uncertainty Analytic Reliability based Stochastic Reliability based
Metamodeling
Construct approximated mathematical model (surrogate model) MINLP Branch and Bound Surrogate based optimization
Optimization
Find an optimal design variable set
Capabilities (Surface Fitting methods)
Surface fitting process consists of three steps:
Selection of a set of design points, Evaluation of the true response quantities at these design points Using the response data to solve for the unknown coefficients in the surface fit model
Surface Fitting Methods
First order Taylor series model Polynomial Regression Kriging Interpolation Artificial Neural Network Multivariate Adaptive Regression Splines (MARS) Linear Quadratic Cubic
Interfacing DAKOTA with Other Simulation Codes
In DAKOTA, there are two different strategies for interfacing i.e., interfacing with an application and interfacing with an approximation
DAKOTA Input File Format
Variables Interface Responses Methods Strategy
Interfacing Mechanisms in DAKOTA
Interfacing with an application (Computational Simulation code) System Calls Forks Direct Function Interfacing with an approximation (Surrogate model) Local Global Multipoint Hierarchical
Capabilities (Parallel Computing)
Single Program Multiple Data parallel programming model MPI and MPI_COMM_WORLD
Parallelism levels
Algorithmic coarse grained Algorithmic fine grained Function evaluation coarse grained Function evaluation fine grained Independent function evaluations Internal linear algebra Separable parts of a single function evaluation Solution steps within a single analysis code
Test cases – Weight Optimization
Weight optimization of a truss structure under vertical load
Objective Function: Minimize the weight of Truss Mathematically : F(x1, x2, x3, x4) =
x
1 1 .
2
x
2
x
3 0 .
6
x
4 Cross sectional area of the truss members (x1, x2, x3, x4) are design variables Vertical deflection constraint and certain end constraints are applied Gradient based method (CONMIN_MFD) was applied Problem is formulated in C, C++, F77 / F90 Executable is linked with DAKOTA input file DAKOTA is executed with the input file to generate the output
A truss structure
x2 x1 x3 weight x4 Design Variables Optimization Results Initial Point Design Variables Final Point x1 x2 x3 x4 20 cm 2 40 cm 2 10 cm 2 10 cm 2 x1 x2 x3 x4 10.63 cm 2 6.65 cm 2 10.64 cm 2 12.86 cm 2 Initial Objective function value 84 kg Final Objective function value Best data captured at function evaluation 112 Total Wall Clock = 0.806 seconds 36.97 kg
Test case – Handling extreme non-linearity
Objective : Find the most optimal solution on a non-linear (real world) response surface Mathematically
f
(
x
1 ,
x
2 ) 1 .
7 * ( 6 ( 1 .
25 6 * cos( ( 3 *
x
1 5 .
4 1 ) * 2
x
2 ) ) ) 1 9 * (
x
1 0 .
6 ) 2 1 16 * (
x
2 0 .
5 ) 2 Gradient based and Non-Gradient based methods were applied Multi-Level hybrid optimization was applied Surrogate based Optimization (SBO) which employs data-sampling, metamodeling and optimization techniques was used. A surface plot of the objective function
Gradient based optimization with different initial points using OPT++
Test 1 2 3 4 initial
x 1
0.0
0.0
0.0
-0.5
initial
x 2
0.0
0.5
-0.5
0.0
optimal
x 1
0.3239
0.3312
0.3140
-0.5922
optimal
x 2
-0.012
0.5759
-0.5778
-0.5021
f
-0.7164
-0.6739
-0.7514
-1.0696
optimum local local local global population
Effect of population size on GA
optimal x 1 optimal x 2 f 200 400 600 -0.5304
-0.6359
-0.6359
-0.5013
-0.4801
-0.4801
-1.0374
-1.0454
-1.0454
computing time (sec.) 26.36
51.72
79.82
Method GA PS CONMIN GA CONMIN
Multilevel hybrid optimization
optimal x -0.5925
-0.5925
1 optimal x -0.5023
-0.5023
2 f -1.0696
-1.0696
computing time (sec.) 12.45
11.44
Comparison of accuracy of surface fitting methods
Fitting method quadratic poly.
cubic poly.
kriging MARS ANN x 1 -0.5007
-0.5788
-0.5981
-0.5659
-0.5530
x 2 -0.5076
-0.4918
-0.5130
-0.4802
-0.4685
f sbo
-1.0024
-1.0675
-1.0675
-1.0555
-1.0381
% error* 6.28
0.19
0.19
1.32
2.95
Effect of number of samples in LHS on the solution (Kriging)
No. of samples 20 30 40 x 1 -0.5969
-0.5981
-0.5957
X 2 -0.5181
-0.5130
-0.5019
f sbo
-1.0654
-1.0675
-1.0695
% error 0.39
0.19
0.01
f real
= -1.0696
* % error =
f sbo
f real
/
f real
* 100
Test case – DAKOTA coupled with in-house solvers
DAKOTA interface with a Inhouse CFD flow solver
Black-box interface of DAKOTA and Flow solver Job file Input File
DAKOTA
Results File Generalized grid of the airfoil Objective Function: Maximize Coefficient of Lift C L Design Variable: Angle of attack (ALPHA) Side constraint: 0 o ALPHA 13 o Gradient based method (CONMIN_FRCG) is used FORK Application Interface is used Extract data Input File Alter Variables File Script File Run Extracted data History File Waits for
Inhouse (Flow Solver)
Grid Computing
DAKOTA (Binary) is distributed for various platforms e.g., Intel Pentium Red Hat, Sun Solaris, SGI IRIX, IBM AIX and Mac OSX. DAKOTA (Source) is also distributed, which can be built for any particular platform. DAKOTA is intended for solving computationally expensive simulations of different applications, enabling DAKOTA on a grid based resource will reduce expense and make it available for various research communities Large scale parallelism and grid computing will be very useful for DAKOTA users, providing quick results, enabling collaborative usage and communication.
DAKOTA version 4.0 with a JAVA Front End is installed on Medusa (Rocks 4.1 cluster), this required installing few additional packages e.g., BLAS, LAPACK, FLEX, YACC and Bison. PGI compiler was required for compiling various algorithms included in the toolkit Optimization, Parameter estimation, Uncertainty quantification and Statistics toolkit DAKOTA is intended for usage among scientists and engineers, this can further collaborated through SURA grid usage Goal is now to enable DAKOTA on SURA grid, it has been enabled on Medusa and can be easily extended to other available clusters. Users from different groups can submit jobs for different applications and there can be collaborative support among them.
Conclusion
Provides access to a broad range of iterative capabilities through a single, relatively simple interface between DAKOTA and simulation code. Interfacing a different iterative method / strategy with the simulation code requires only a change in few commands of the DAKOTA input file Provides access to a variety of different optimization methods and algorithms, with much of the complexity of the optimization software interfaces hidden from the user Designed to exploit massively parallel computing platforms through a multi-level parallelism approach which takes advantage of opportunities for concurrent function evaluations that are provided by the different optimization algorithms Flexibility, and extensibility, of the C++ object-oriented design approach used in creating DAKOTA permits the rapid development of more sophisticated optimization strategies such as surrogate-based optimization, hybrid optimization and optimization under uncertainty
Input File – Truss design
strategy, #
Input file for Truss design (Gradient based method)
single_method graphics tabular_graphics_data method, # # # variables, conmin_mfd convergence_tolerance = 1e-4 conmin_frcg optpp_q_newton optimization_type minimize continuous_design = 4 cdv_descriptor 'x1' 'x2‘ ‘x3’ ‘x4’ cdv_initial_point 20.0 40.0 10.0 10.0
cdv_lower_bounds 0.0 0.0 0.0 0.0
interface, # application, system application direct analysis_driver = ' a.out
' parameters_file = 'test.in' results_file = 'test.out' file_tag responses, num_objective_functions = 1 num_nonlinear_inequality_constraints = 5 numerical_gradients method_source dakota interval_type central fd_gradient_step_size = 0.001
no_hessians \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
Input File – Handling Extreme non-linearity
strategy,
Non - Gradient based method
single_method graphics tabular_graphics_data method, output verbose max_iterations 300 max_function_evaluations 500 solution_accuracy = 1.e-2 seed = 1234 sgopt_pga_real initialization_type random population_size = 200 selection_pressure rank replacement_type elitist = 1 crossover_type uniform crossover_rate = 0.92
mutation_type offset_cauchy dimension_rate = .12
population_rate = .91 non_adaptive variables, continuous_design = 2 cdv_initial_point 0.0 0.0 cdv_lower_bounds -1.0 -1.0 cdv_upper_bounds 1.0 1.0 cdv_descriptor 'x1' 'x2‘ interface, application fork, analysis_driver = 'a.out' parameters_file = 'sgopt-real.in' results_file = 'sgopt-real.out' file_tag responses, num_objective_functions = 1 no_gradients no_hessians \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
Input File – Handling Extreme non-linearity
strategy, method, method, method, graphics tabular_graphics_data multi_level uncoupled method_list = 'GA' 'PS' 'NLP' id_method = 'GA' model_type single variables_pointer = 'V1' interface_pointer = 'I1' responses_pointer = 'R1' max_function_evaluations 10 sgopt_pga_real seed = 1234 population_size = 20 verbose output id_method = 'PS' model_type single variables_pointer = 'V1' interface_pointer = 'I1' responses_pointer = 'R1' sgopt_pattern_search stochastic seed = 1234 verbose output initial_delta = 0.1
threshold_delta = 1.e-2 solution_accuracy = 1.e-2 exploratory_moves best_first id_method = 'NLP' model_type single variables_pointer = 'V1' interface_pointer = 'I1' responses_pointer = 'R2' conmin_frcg gradient_tolerance = 1.e-2 convergence_tolerance = 1.e-2 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ interface, variables, responses, responses, id_interface = 'I1' application fork, analysis_driver= 'a.out' parameters_file= 'multilevel.in' results_file= 'multi.out' file_tag id_variables = 'V1' continuous_design = 2 cdv_initial_point 0.0 0.0
cdv_upper_bounds 1.0 1.0 cdv_lower_bounds -1.0 -1.0 cdv_descriptor 'x1' 'x2' id_responses = 'R1' num_objective_functions = 1 no_gradients no_hessians id_responses = 'R2' num_objective_functions = 1 numerical_gradients \ method_source dakota \ interval_type central fd_step_size = 0.0001 no_hessians \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
Multi-Level Optimization
Input File – Handling Extreme non-linearity
strategy, surrogate_based_opt graphics tabular_graphics_data max_iterations = 2 opt_method_pointer = 'NLP' trust_region initial_size = 1.0
minimum_size = 1.0e-6 contraction_factor = 0.50
expansion_factor = 1.50
method, id_method = 'NLP' model_type layered interface_pointer = 'SFN' responses_pointer = 'SFN_GRAD' optpp_q_newton, max_iterations = 50, convergence_tolerance = 1e-4 variables, continuous_design = 2 cdv_initial_point -0.5 -0.5
cdv_lower_bounds -1.0 -1.0
cdv_upper_bounds 1.0 1.0 cdv_descriptor 'x1' 'x2' interface, id_interface = 'SFN' approximation global, dace_method_pointer = 'SAMPLING' kriging correlations 1.0 1.0
Surrogate Based Optimization
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ responses, id_responses = 'SFN_GRAD' num_objective_functions = 1 numerical_gradients method_source dakota interval_type central fd_step_size = 0.0001
no_hessians # SAMPLING method specifications for building # surrogate function(s).
method, id_method = 'SAMPLING' model_type single interface_pointer='TFN' responses_pointer='TFN_GRAD‘ dace lhs seed = 123 samples = 30 interface, application system, id_interface = 'TFN' analysis_driver = 'a.out' parameters_file = 'surrogate.in' results_file = 'surrogate.out' file_tag responses, id_responses = 'TFN_GRAD‘ num_objective_functions = 1 no_gradients no_hessians \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \