Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.m (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.m (revision 24532) @@ -0,0 +1,892 @@ +% +% definition for the dakota_method class. +% +% [dm]=dakota_method(method) +% +% where the required input is: +% method (char, beginning of method name) +% +% and the output properties and defaults are: +% method (char, full method name, '') +% type (char, type of method, '') +% variables (cell array, applicable variable types, {}) +% lcspec (cell array, linear constraint specs, {}) +% responses (cell array, applicable response types, {}) +% ghspec (cell array, gradient and hessian specs, {}) +% params (structure, method-dependent parameters, []) +% +% this class is used to guide the writing of a dakota input +% file for the specified dakota_method. +% +% note that zero arguments constructs a default instance; one +% argument of the class copies the instance; and one argument +% with enough characters to match a unique method constructs +% a new instance of that method. +% +% "Copyright 2009, by the California Institute of Technology. +% ALL RIGHTS RESERVED. United States Government Sponsorship +% acknowledged. Any commercial use must be negotiated with +% the Office of Technology Transfer at the California Institute +% of Technology. (J. Schiermeier, NTR 47078) +% +% This software may be subject to U.S. export control laws. +% By accepting this software, the user agrees to comply with +% all applicable U.S. export laws and regulations. User has the +% responsibility to obtain export licenses, or other export +% authority as may be required before exporting such information +% to foreign countries or providing access to foreign persons." +% +classdef dakota_method + properties (SetAccess=private) + method =''; + type =''; + variables={}; + lcspec ={}; + responses={}; + ghspec ={}; + end + properties + params =struct(); + end + + methods + function [dm]=dakota_method(method) + + switch nargin + case 0 + % create a default object + case 1 + % copy the object or create the object from the input + if (nargin == 1) && isa(method,'dakota_method') + dm=method; + else + mlist={... + 'dot_bfgs',... + 'dot_frcg',... + 'dot_mmfd',... + 'dot_slp',... + 'dot_sqp',... + 'npsol_sqp',... + 'conmin_frcg',... + 'conmin_mfd',... + 'optpp_cg',... + 'optpp_q_newton',... + 'optpp_fd_newton',... + 'optpp_newton',... + 'optpp_pds',... + 'asynch_pattern_search',... + 'coliny_cobyla',... + 'coliny_direct',... + 'coliny_ea',... + 'coliny_pattern_search',... + 'coliny_solis_wets',... + 'ncsu_direct',... + 'surrogate_based_local',... + 'surrogate_based_global',... + 'moga',... + 'soga',... + 'nl2sol',... + 'nlssol_sqp',... + 'optpp_g_newton',... + 'nond_sampling',... + 'nond_local_reliability',... + 'nond_global_reliability',... + 'nond_polynomial_chaos',... + 'nond_stoch_collocation',... + 'nond_evidence',... + 'dace',... + 'fsu_quasi_mc',... + 'fsu_cvt',... + 'vector_parameter_study',... + 'list_parameter_study',... + 'centered_parameter_study',... + 'multidim_parameter_study',... + 'bayes_calibration',... + }; + + mlist2={}; + for i=1:length(mlist) + if strncmpi(method,mlist{i},length(method)) + mlist2(end+1)=mlist(i); + end + end + +% check for a unique match in the list of methods + + switch length(mlist2) + case 0 + error('Unrecognized method: ''%s''.',... + method); + case 1 + dm.method=mlist2{1}; + otherwise + error('Non-unique method: ''%s'' matches %s.',... + method,string_cell(mlist2)); + end + +% assign the default values for the method + + switch dm.method + case {'dot_bfgs',... + 'dot_frcg'} + dm.type ='dot'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.optimization_type='minimize'; + case {'dot_mmfd',... + 'dot_slp',... + 'dot_sqp'} + dm.type ='dot'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.optimization_type='minimize'; + + case {'npsol_sqp'} + dm.type ='npsol'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.verify_level=-1; + dm.params.function_precision=1.e-10; + dm.params.linesearch_tolerance=0.9; + + case {'conmin_frcg'} + dm.type ='conmin'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + case {'conmin_mfd'} + dm.type ='conmin'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + + case {'optpp_cg'} + dm.type ='optpp'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.max_step=1000.; + dm.params.gradient_tolerance=1.e-4; + case {'optpp_q_newton',... + 'optpp_fd_newton',... + 'optpp_newton'} + dm.type ='optpp'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.value_based_line_search=false; + dm.params.gradient_based_line_search=false; + dm.params.trust_region=false; + dm.params.tr_pds=false; + dm.params.max_step=1000.; + dm.params.gradient_tolerance=1.e-4; + dm.params.merit_function='argaez_tapia'; + dm.params.central_path=dm.params.merit_function; + dm.params.steplength_to_boundary=0.99995; + dm.params.centering_parameter=0.2; + case {'optpp_pds'} + dm.type ='optpp'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.search_scheme_size=32; + + case {'asynch_pattern_search'} + dm.type ='apps'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_function_evaluations=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.initial_delta=1.0; + dm.params.threshold_delta=0.01; + dm.params.contraction_factor=0.5; + dm.params.solution_target=false; + dm.params.synchronization='nonblocking'; + dm.params.merit_function='merit2_smooth'; + dm.params.constraint_penalty=1.0; + dm.params.smoothing_factor=1.0; + + case {'coliny_cobyla'} + dm.type ='coliny'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.show_misc_options=false; + dm.params.misc_options={}; + dm.params.solution_accuracy=-Inf; + dm.params.initial_delta=[]; + dm.params.threshold_delta=[]; + case {'coliny_direct'} + dm.type ='coliny'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.show_misc_options=false; + dm.params.misc_options={}; + dm.params.solution_accuracy=-Inf; + dm.params.division='major_dimension'; + dm.params.global_balance_parameter=0.0; + dm.params.local_balance_parameter=1.e-8; + dm.params.max_boxsize_limit=0.0; + dm.params.min_boxsize_limit=0.0001; + dm.params.constraint_penalty=1000.0; + case {'coliny_ea'} + dm.type ='coliny'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.show_misc_options=false; + dm.params.misc_options={}; + dm.params.solution_accuracy=-Inf; + dm.params.seed=false; + dm.params.population_size=50; + dm.params.initialization_type='unique_random'; + dm.params.fitness_type='linear_rank'; + dm.params.replacement_type='elitist'; + dm.params.random=[]; + dm.params.chc=[]; + dm.params.elitist=[]; + dm.params.new_solutions_generated='population_size - replacement_size'; + dm.params.crossover_type='two_point'; + dm.params.crossover_rate=0.8; + dm.params.mutation_type='offset_normal'; + dm.params.mutation_scale=0.1; + dm.params.mutation_range=1; + dm.params.dimension_ratio=1.0; + dm.params.mutation_rate=1.0; + dm.params.non_adaptive=false; + case {'coliny_pattern_search'} + dm.type ='coliny'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.show_misc_options=false; + dm.params.misc_options={}; + dm.params.solution_accuracy=-Inf; + dm.params.stochastic=false; + dm.params.seed=false; + dm.params.initial_delta=[]; + dm.params.threshold_delta=[]; + dm.params.constraint_penalty=1.0; + dm.params.constant_penalty=false; + dm.params.pattern_basis='coordinate'; + dm.params.total_pattern_size=false; + dm.params.no_expansion=false; + dm.params.expand_after_success=1; + dm.params.contraction_factor=0.5; + dm.params.synchronization='nonblocking'; + dm.params.exploratory_moves='basic_pattern'; + case {'coliny_solis_wets'} + dm.type ='coliny'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.show_misc_options=false; + dm.params.misc_options={}; + dm.params.solution_accuracy=-Inf; + dm.params.seed=false; + dm.params.initial_delta=[]; + dm.params.threshold_delta=[]; + dm.params.no_expansion=false; + dm.params.expand_after_success=5; + dm.params.contract_after_failure=3; + dm.params.contraction_factor=0.5; + dm.params.constraint_penalty=1.0; + dm.params.constant_penalty=false; + + case {'ncsu_direct'} + dm.type ='ncsu'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; % ? + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; % ? + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.scaling=false; + dm.params.solution_accuracy=0.; + dm.params.min_boxsize_limit=1.e-8; + dm.params.vol_boxsize_limit=1.e-8; + +% case {'surrogate_based_local',... +% 'surrogate_based_global'} + + case {'moga'} + dm.type ='jega'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.seed=false; + dm.params.log_file='JEGAGlobal.log'; + dm.params.population_size=50; + dm.params.print_each_pop=false; +% according to documentation, uses method-independent control +% dm.params.output='normal'; + dm.params.initialization_type='unique_random'; + dm.params.mutation_type='replace_uniform'; + dm.params.mutation_scale=0.15; + dm.params.mutation_rate=0.08; + dm.params.replacement_type=''; + dm.params.below_limit=6; + dm.params.shrinkage_percentage=0.9; + dm.params.crossover_type='shuffle_random'; + dm.params.multi_point_binary=[]; + dm.params.multi_point_parameterized_binary=[]; + dm.params.multi_point_real=[]; + dm.params.shuffle_random=[]; + dm.params.num_parents=2; + dm.params.num_offspring=2; + dm.params.crossover_rate=0.8; + dm.params.fitness_type=''; + dm.params.niching_type=false; + dm.params.radial=[0.01]; + dm.params.distance=[0.01]; + dm.params.metric_tracker=false; + dm.params.percent_change=0.1; + dm.params.num_generations=10; + dm.params.postprocessor_type=false; + dm.params.orthogonal_distance=[0.01]; + case {'soga'} + dm.type ='jega'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'objective_function',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.seed=false; + dm.params.log_file='JEGAGlobal.log'; + dm.params.population_size=50; + dm.params.print_each_pop=false; + dm.params.output='normal'; + dm.params.initialization_type='unique_random'; + dm.params.mutation_type='replace_uniform'; + dm.params.mutation_scale=0.15; + dm.params.mutation_rate=0.08; + dm.params.replacement_type=''; + dm.params.below_limit=6; + dm.params.shrinkage_percentage=0.9; + dm.params.crossover_type='shuffle_random'; + dm.params.multi_point_binary=[]; + dm.params.multi_point_parameterized_binary=[]; + dm.params.multi_point_real=[]; + dm.params.shuffle_random=[]; + dm.params.num_parents=2; + dm.params.num_offspring=2; + dm.params.crossover_rate=0.8; + dm.params.fitness_type='merit_function'; + dm.params.constraint_penalty=1.0; + dm.params.replacement_type=''; + dm.params.convergence_type=false; + dm.params.num_generations=10; + dm.params.percent_change=0.1; + + case {'nl2sol'} + dm.type ='lsq'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'least_squares_term'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.scaling=false; + dm.params.function_precision=1.e-10; + dm.params.absolute_conv_tol=-1.; + dm.params.x_conv_tol=-1.; + dm.params.singular_conv_tol=-1.; + dm.params.singular_radius=-1.; + dm.params.false_conv_tol=-1.; + dm.params.initial_trust_radius=-1.; + dm.params.covariance=0; + dm.params.regression_stressbalances=false; + case {'nlssol_sqp'} + dm.type ='lsq'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'least_squares_term',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.constraint_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.verify_level=-1; + dm.params.function_precision=1.e-10; + dm.params.linesearch_tolerance=0.9; + case {'optpp_g_newton'} + dm.type ='lsq'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={'linear_inequality_constraint',... + 'linear_equality_constraint'}; + dm.responses={'least_squares_term',... + 'nonlinear_inequality_constraint',... + 'nonlinear_equality_constraint'}; + dm.ghspec ={'grad'}; + dm.params.max_iterations=false; + dm.params.max_function_evaluations=false; + dm.params.convergence_tolerance=false; + dm.params.output=false; + dm.params.speculative=false; + dm.params.scaling=false; + dm.params.value_based_line_search=false; + dm.params.gradient_based_line_search=false; + dm.params.trust_region=false; + dm.params.tr_pds=false; + dm.params.max_step=1000.; + dm.params.gradient_tolerance=1.e-4; + dm.params.merit_function='argaez_tapia'; + dm.params.central_path=dm.params.merit_function; + dm.params.steplength_to_boundary=0.99995; + dm.params.centering_parameter=0.2; + + case {'nond_sampling'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'histogram_bin_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={}; +% not documented, but apparently works + dm.params.output=false; + dm.params.seed=false; + dm.params.fixed_seed=false; + dm.params.rng=false; + dm.params.samples=false; + dm.params.sample_type='lhs'; + dm.params.all_variables=false; + dm.params.variance_based_decomp=false; + dm.params.previous_samples=0; + case {'nond_local_reliability'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={'grad'}; +% not documented, but may work + dm.params.output=false; + dm.params.max_iterations=false; + dm.params.convergence_tolerance=false; + dm.params.mpp_search=false; + dm.params.sqp=false; + dm.params.nip=false; + dm.params.integration='first_order'; + dm.params.refinement=false; + dm.params.samples=0; + dm.params.seed=false; + case {'nond_global_reliability'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={'grad'}; +% not documented, but may work + dm.params.output=false; + dm.params.x_gaussian_process=false; + dm.params.u_gaussian_process=false; + dm.params.all_variables=false; + dm.params.seed=false; + case {'nond_polynomial_chaos'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={'grad'}; +% not documented, but may work + dm.params.output=false; + dm.params.expansion_order=[]; + dm.params.expansion_terms=[]; + dm.params.quadrature_order=[]; + dm.params.sparse_grid_level=[]; + dm.params.expansion_samples=[]; + dm.params.incremental_lhs=false; + dm.params.collocation_points=[]; + dm.params.collocation_ratio=[]; + dm.params.reuse_samples=false; + dm.params.expansion_import_file=''; + dm.params.seed=false; + dm.params.fixed_seed=false; + dm.params.samples=0; + dm.params.sample_type='lhs'; + dm.params.all_variables=false; + case {'nond_stoch_collocation'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={'grad'}; +% not documented, but may work + dm.params.output=false; + dm.params.quadrature_order=[]; + dm.params.sparse_grid_level=[]; + dm.params.seed=false; + dm.params.fixed_seed=false; + dm.params.samples=0; + dm.params.sample_type='lhs'; + dm.params.all_variables=false; + case {'nond_evidence'} + dm.type ='nond'; + dm.variables={'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'response_function'}; + dm.ghspec ={'grad'}; +% not documented, but may work + dm.params.output=false; + dm.params.seed=false; + dm.params.samples=10000; + + case {'dace'} + dm.type ='dace'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.grid=false; + dm.params.random=false; + dm.params.oas=false; + dm.params.lhs=false; + dm.params.oa_lhs=false; + dm.params.box_behnken=false; + dm.params.central_composite=false; + dm.params.seed=false; + dm.params.fixed_seed=false; + dm.params.samples=false; + dm.params.symbols=false; + dm.params.quality_metrics=false; + dm.params.variance_based_decomp=false; + case {'fsu_quasi_mc'} + dm.type ='dace'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.halton=false; + dm.params.hammersley=false; + dm.params.samples=0; + dm.params.sequence_start=[0]; + dm.params.sequence_leap=[1]; + dm.params.prime_base=false; + dm.params.fixed_sequence=false; + dm.params.latinize=false; + dm.params.variance_based_decomp=false; + dm.params.quality_metrics=false; + case {'fsu_cvt'} + dm.type ='dace'; + dm.variables={'continuous_design',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.seed=false; + dm.params.fixed_seed=false; + dm.params.samples=0; + dm.params.num_trials=10000; + dm.params.trial_type='random'; + dm.params.latinize=false; + dm.params.variance_based_decomp=false; + dm.params.quality_metrics=false; + + case {'vector_parameter_study'} + dm.type ='param'; + dm.variables={'continuous_design',... + 'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.output=false; + dm.params.final_point=[]; + dm.params.step_length=[]; + dm.params.num_steps=[]; + dm.params.step_vector=[]; + dm.params.num_steps=[]; + case {'list_parameter_study'} + dm.type ='param'; + dm.variables={'continuous_design',... + 'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.output=false; + dm.params.list_of_points=[]; + case {'centered_parameter_study'} + dm.type ='param'; + dm.variables={'continuous_design',... + 'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.output=false; + dm.params.percent_delta=[]; + dm.params.deltas_per_variable=[]; + case {'multidim_parameter_study'} + dm.type ='param'; + dm.variables={'continuous_design',... + 'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function'}; + dm.ghspec ={}; + dm.params.output=false; + dm.params.partitions=[]; + case {'bayes_calibration'} + dm.type ='bayes'; + dm.variables={'continuous_design',... + 'normal_uncertain',... + 'uniform_uncertain',... + 'continuous_state'}; + dm.lcspec ={}; + dm.responses={'objective_function',... + 'response_function',... + 'calibration_function'}; + dm.ghspec ={}; + dm.params.queso=false; + dm.params.dream=false; + dm.params.gpmsa=false; + dm.params.samples=0; + dm.params.seed=false; + dm.params.output=false; + dm.params.metropolis_hastings=false; + dm.params.proposal_covariance=false; + dm.params.diagonal=false; + dm.params.values=[]; + + + otherwise + error('Unimplemented method: ''%s''.',dm.method); + end + + end + +% if more than one argument, issue warning + + otherwise + warning('dakota_method:extra_arg',... + 'Extra arguments for object of class ''%s''.',... + class(dm)); + end + + end + + function []=disp(dm) + +% display the object + + for i=1:numel(dm) + disp(sprintf('\nclass ''%s'' object ''%s%s'' = \n',... + class(dm),inputname(1),string_dim(dm,i))); + disp(sprintf(' method: ''%s''' ,dm(i).method)); + disp(sprintf(' type: ''%s''' ,dm(i).type)); + disp(sprintf(' variables: %s' ,string_cell(dm(i).variables))); + disp(sprintf(' lcspec: %s' ,string_cell(dm(i).lcspec))); + disp(sprintf(' responses: %s' ,string_cell(dm(i).responses))); + disp(sprintf(' ghspec: %s\n' ,string_cell(dm(i).ghspec))); + +% display the parameters within the object + + fnames=fieldnames(dm(i).params); + maxlen=0; + for j=1:numel(fnames) + maxlen=max(maxlen,length(fnames{j})); + end + + for j=1:numel(fnames) + disp(sprintf([' params.%-' num2str(maxlen+1) 's: %s'],... + fnames{j},any2str(dm(i).params.(fnames{j})))); + end + end + + end + end +end Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.py =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.py (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dakota_method.py (revision 24532) @@ -0,0 +1,906 @@ +#move this later +from helpers import * + +from MatlabFuncs import * +import numpy as np + + +class dakota_method(object): + ''' + definition for the dakota_method class. + + [dm] = dakota_method(method) + + where the required input is: + method (char, beginning of method name) + + and the output properties and defaults are: + method (char, full method name, '') + type (char, type of method, '') + variables (cell array, applicable variable types, []) + lcspec (cell array, linear constraint specs, []) + responses (cell array, applicable response types, []) + ghspec (cell array, gradient and hessian specs, []) + params (structure, method - depent parameters, []) + + this class is used to guide the writing of a dakota input + file for the specified dakota_method. + + note that zero arguments constructs a default instance one + argument of the class copies the instance and one argument + with enough characters to match a unique method constructs + a new instance of that method. + + "Copyright 2009, by the California Institute of Technology. + ALL RIGHTS RESERVED. United States Government Sponsorship + acknowledged. Any commercial use must be negotiated with + the Office of Technology Transfer at the California Institute + of Technology. (J. Schiermeier, NTR 47078) + + This software may be subject to U.S. export control laws. + By accepting this software, the user agrees to comply with + all applicable U.S. export laws and regulations. User has the + responsibility to obtain export licenses, or other export + authority as may be required before exporting such np.information + to foreign countries or providing access to foreign persons." + ''' + + def __init__(self, *args): + self.method = '' + self.type = '' + self.variables = [] + self.lcspec = [] + self.responses = [] + self.ghspec = [] + #properites + self.params = struct() + + @staticmethod + def dakota_method(*args): + dm = dakota_method() + # return a default object + if len(args) == 0: + return dm + + # copy the object or create the object from the input + elif len(args) == 1: + method = args[0] + + #given argument was a method, copy it + if isinstance(method, dakota_method): + #dm = method + object = method + for field in object.keys(): + if field in vars(dm): + setattr(dm, field, object[field]) + return dm + + #given argument was a way of constructing a method + else: + mlist = ['dot_bfgs', + 'dot_frcg', + 'dot_mmfd', + 'dot_slp', + 'dot_sqp', + 'npsol_sqp', + 'conmin_frcg', + 'conmin_mfd', + 'optpp_cg', + 'optpp_q_newton', + 'optpp_fd_newton', + 'optpp_newton', + 'optpp_pds', + 'asynch_pattern_search', + 'coliny_cobyla', + 'coliny_direct', + 'coliny_ea', + 'coliny_pattern_search', + 'coliny_solis_wets', + 'ncsu_direct', + 'surrogate_based_local', + 'surrogate_based_global', + 'moga', + 'soga', + 'nl2sol', + 'nlssol_sqp', + 'optpp_g_newton', + 'nond_sampling', + 'nond_local_reliability', + 'nond_global_reliability', + 'nond_polynomial_chaos', + 'nond_stoch_collocation', + 'nond_evidence', + 'dace', + 'fsu_quasi_mc', + 'fsu_cvt', + 'vector_parameter_study', + 'list_parameter_study', + 'centered_parameter_study', + 'multidim_parameter_study', + 'bayes_calibration'] + + mlist2 = [] + for i in range(len(mlist)): + if strncmpi(method, mlist[i], len(method)): + mlist2.append(mlist[i]) + # check for a unique match in the list of methods + length = len(mlist2) + if length == 0: + raise RuntimeError('Unrecognized method: ' + str(method) + '.') + elif length == 1: + dm.method = mlist2[0] + else: + raise RuntimeError('Non - unique method: ' + str(method) + ' matches ' + string_cell(mlist2)) + + # assign the default values for the method + # switch dm.method + if dm.method in ['dot_bfgs', 'dot_frcg']: + dm.type = 'dot' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.optimization_type = 'minimize' + + elif dm.method in ['dot_mmfd', 'dot_slp', 'dot_sqp']: + dm.type = 'dot' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.optimization_type = 'minimize' + + elif dm.method == 'npsol_sqp': + dm.type = 'npsol' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.verify_level = -1 + dm.params.function_precision = 1.0e-10 + dm.params.linesearch_tolerance = 0.9 + + elif dm.method == 'conmin_frcg': + dm.type = 'conmin' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + + elif dm.method == 'conmin_mfd': + dm.type = 'conmin' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + + elif dm.method == 'optpp_cg': + dm.type = 'optpp' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.max_step = 1000. + dm.params.gradient_tolerance = 1.0e-4 + + elif dm.method in ['optpp_q_newton', + 'optpp_fd_newton', + 'optpp_newton']: + dm.type = 'optpp' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.value_based_line_search = False + dm.params.gradient_based_line_search = False + dm.params.trust_region = False + dm.params.tr_pds = False + dm.params.max_step = 1000. + dm.params.gradient_tolerance = 1.0e-4 + dm.params.merit_function = 'argaez_tapia' + dm.params.central_path = dm.params.merit_function + dm.params.steplength_to_boundary = 0.99995 + dm.params.centering_parameter = 0.2 + + elif dm.method == 'optpp_pds': + dm.type = 'optpp' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.search_scheme_size = 32 + + elif dm.method == 'asynch_pattern_search': + dm.type = 'apps' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_function_evaluations = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.initial_delta = 1.0 + dm.params.threshold_delta = 0.01 + dm.params.contraction_factor = 0.5 + dm.params.solution_target = False + dm.params.synchronization = 'nonblocking' + dm.params.merit_function = 'merit2_smooth' + dm.params.constraint_penalty = 1.0 + dm.params.smoothing_factor = 1.0 + + elif dm.method == 'coliny_cobyla': + dm.type = 'coliny' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.show_misc_options = False + dm.params.misc_options = [] + dm.params.solution_accuracy = -np.inf + dm.params.initial_delta = [] + dm.params.threshold_delta = [] + + elif dm.method == 'coliny_direct': + dm.type = 'coliny' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.show_misc_options = False + dm.params.misc_options = [] + dm.params.solution_accuracy = -np.inf + dm.params.division = 'major_dimension' + dm.params.global_balance_parameter = 0.0 + dm.params.local_balance_parameter = 1.0e-8 + dm.params.max_boxsize_limit = 0.0 + dm.params.min_boxsize_limit = 0.0001 + dm.params.constraint_penalty = 1000.0 + + elif dm.method == 'coliny_ea': + dm.type = 'coliny' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.show_misc_options = False + dm.params.misc_options = [] + dm.params.solution_accuracy = -np.inf + dm.params.seed = False + dm.params.population_size = 50 + dm.params.initialization_type = 'unique_random' + dm.params.fitness_type = 'linear_rank' + dm.params.replacement_type = 'elitist' + dm.params.random = [] + dm.params.chc = [] + dm.params.elitist = [] + dm.params.new_solutions_generated = 'population_size-replacement_size' + dm.params.crossover_type = 'two_point' + dm.params.crossover_rate = 0.8 + dm.params.mutation_type = 'offset_normal' + dm.params.mutation_scale = 0.1 + dm.params.mutation_range = 1 + dm.params.dimension_ratio = 1.0 + dm.params.mutation_rate = 1.0 + dm.params.non_adaptive = False + + elif dm.method == 'coliny_pattern_search': + dm.type = 'coliny' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.show_misc_options = False + dm.params.misc_options = [] + dm.params.solution_accuracy = -np.inf + dm.params.stochastic = False + dm.params.seed = False + dm.params.initial_delta = [] + dm.params.threshold_delta = [] + dm.params.constraint_penalty = 1.0 + dm.params.constant_penalty = False + dm.params.pattern_basis = 'coordinate' + dm.params.total_pattern_size = False + dm.params.no_expansion = False + dm.params.expand_after_success = 1 + dm.params.contraction_factor = 0.5 + dm.params.synchronization = 'nonblocking' + dm.params.exploratory_moves = 'basic_pattern' + + elif dm.method == 'coliny_solis_wets': + dm.type = 'coliny' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.show_misc_options = False + dm.params.misc_options = [] + dm.params.solution_accuracy = -np.inf + dm.params.seed = False + dm.params.initial_delta = [] + dm.params.threshold_delta = [] + dm.params.no_expansion = False + dm.params.expand_after_success = 5 + dm.params.contract_after_failure = 3 + dm.params.contraction_factor = 0.5 + dm.params.constraint_penalty = 1.0 + dm.params.constant_penalty = False + + elif dm.method == 'ncsu_direct': + dm.type = 'ncsu' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] # ? + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] # ? + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.scaling = False + dm.params.solution_accuracy = 0. + dm.params.min_boxsize_limit = 1.0e-8 + dm.params.vol_boxsize_limit = 1.0e-8 + + #if dm.method in ['surrogate_based_local', + #'surrogate_based_global']: + + elif dm.method == 'moga': + dm.type = 'jega' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.output = False + dm.params.scaling = False + dm.params.seed = False + dm.params.log_file = 'JEGAGlobal.log' + dm.params.population_size = 50 + dm.params.print_each_pop = False + #according to documentation, uses method - indepent control + #dm.params.output = 'normal' + dm.params.initialization_type = 'unique_random' + dm.params.mutation_type = 'replace_uniform' + dm.params.mutation_scale = 0.15 + dm.params.mutation_rate = 0.08 + dm.params.replacement_type = '' + dm.params.below_limit = 6 + dm.params.shrinkage_percentage = 0.9 + dm.params.crossover_type = 'shuffle_random' + dm.params.multi_point_binary = [] + dm.params.multi_point_parameterized_binary = [] + dm.params.multi_point_real = [] + dm.params.shuffle_random = [] + dm.params.num_parents = 2 + dm.params.num_offspring = 2 + dm.params.crossover_rate = 0.8 + dm.params.fitness_type = '' + dm.params.niching_type = False + dm.params.radial = [0.01] + dm.params.distance = [0.01] + dm.params.metric_tracker = False + dm.params.percent_change = 0.1 + dm.params.num_generations = 10 + dm.params.postprocessor_type = False + dm.params.orthogonal_distance = [0.01] + + elif dm.method == 'soga': + dm.type = 'jega' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['objective_function', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.output = False + dm.params.scaling = False + dm.params.seed = False + dm.params.log_file = 'JEGAGlobal.log' + dm.params.population_size = 50 + dm.params.print_each_pop = False + dm.params.output = 'normal' + dm.params.initialization_type = 'unique_random' + dm.params.mutation_type = 'replace_uniform' + dm.params.mutation_scale = 0.15 + dm.params.mutation_rate = 0.08 + dm.params.replacement_type = '' + dm.params.below_limit = 6 + dm.params.shrinkage_percentage = 0.9 + dm.params.crossover_type = 'shuffle_random' + dm.params.multi_point_binary = [] + dm.params.multi_point_parameterized_binary = [] + dm.params.multi_point_real = [] + dm.params.shuffle_random = [] + dm.params.num_parents = 2 + dm.params.num_offspring = 2 + dm.params.crossover_rate = 0.8 + dm.params.fitness_type = 'merit_function' + dm.params.constraint_penalty = 1.0 + dm.params.replacement_type = '' + dm.params.convergence_type = False + dm.params.num_generations = 10 + dm.params.percent_change = 0.1 + + elif dm.method == 'nl2sol': + dm.type = 'lsq' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['least_squares_term'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.scaling = False + dm.params.function_precision = 1.0e-10 + dm.params.absolute_conv_tol = -1. + dm.params.x_conv_tol = -1. + dm.params.singular_conv_tol = -1. + dm.params.singular_radius = -1. + dm.params.False_conv_tol = -1. + dm.params.initial_trust_radius = -1. + dm.params.covariance = 0 + dm.params.regression_stressbalances = False + + elif dm.method == 'nlssol_sqp': + dm.type = 'lsq' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['least_squares_term', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.constraint_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.verify_level = -1 + dm.params.function_precision = 1.0e-10 + dm.params.linesearch_tolerance = 0.9 + + elif dm.method == 'optpp_g_newton': + dm.type = 'lsq' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = ['linear_inequality_constraint', + 'linear_equality_constraint'] + dm.responses = ['least_squares_term', + 'nonlinear_inequality_constraint', + 'nonlinear_equality_constraint'] + dm.ghspec = ['grad'] + dm.params.max_iterations = False + dm.params.max_function_evaluations = False + dm.params.convergence_tolerance = False + dm.params.output = False + dm.params.speculative = False + dm.params.scaling = False + dm.params.value_based_line_search = False + dm.params.gradient_based_line_search = False + dm.params.trust_region = False + dm.params.tr_pds = False + dm.params.max_step = 1000. + dm.params.gradient_tolerance = 1.0e-4 + dm.params.merit_function = 'argaez_tapia' + dm.params.central_path = dm.params.merit_function + dm.params.steplength_to_boundary = 0.99995 + dm.params.centering_parameter = 0.2 + + elif dm.method == 'nond_sampling': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = [] + # not documented, but apparently works + dm.params.output = False + dm.params.seed = False + dm.params.fixed_seed = False + dm.params.rng = False + dm.params.samples = False + dm.params.sample_type = 'lhs' + dm.params.all_variables = False + dm.params.variance_based_decomp = False + dm.params.previous_samples = 0 + + elif dm.method == 'nond_local_reliability': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = ['grad'] + # not documented, but may work + dm.params.output = False + dm.params.max_iterations = False + dm.params.convergence_tolerance = False + dm.params.mpp_search = False + dm.params.sqp = False + dm.params.nip = False + dm.params.integration = 'first_order' + dm.params.refinement = False + dm.params.samples = 0 + dm.params.seed = False + + elif dm.method == 'nond_global_reliability': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = ['grad'] + # not documented, but may work + dm.params.output = False + dm.params.x_gaussian_process = False + dm.params.u_gaussian_process = False + dm.params.all_variables = False + dm.params.seed = False + + elif dm.method == 'nond_polynomial_chaos': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = ['grad'] + # not documented, but may work + dm.params.output = False + dm.params.expansion_order = [] + dm.params.expansion_terms = [] + dm.params.quadrature_order = [] + dm.params.sparse_grid_level = [] + dm.params.expansion_samples = [] + dm.params.incremental_lhs = False + dm.params.collocation_points = [] + dm.params.collocation_ratio = [] + dm.params.reuse_samples = False + dm.params.expansion_import_file = '' + dm.params.seed = False + dm.params.fixed_seed = False + dm.params.samples = 0 + dm.params.sample_type = 'lhs' + dm.params.all_variables = False + + elif dm.method == 'nond_stoch_collocation': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = ['grad'] + # not documented, but may work + dm.params.output = False + dm.params.quadrature_order = [] + dm.params.sparse_grid_level = [] + dm.params.seed = False + dm.params.fixed_seed = False + dm.params.samples = 0 + dm.params.sample_type = 'lhs' + dm.params.all_variables = False + + elif dm.method == 'nond_evidence': + dm.type = 'nond' + dm.variables = ['normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['response_function'] + dm.ghspec = ['grad'] + # not documented, but may work + dm.params.output = False + dm.params.seed = False + dm.params.samples = 10000 + + elif dm.method == 'dace': + dm.type = 'dace' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.grid = False + dm.params.random = False + dm.params.oas = False + dm.params.lhs = False + dm.params.oa_lhs = False + dm.params.box_behnken = False + dm.params.central_composite = False + dm.params.seed = False + dm.params.fixed_seed = False + dm.params.samples = False + dm.params.symbols = False + dm.params.quality_metrics = False + dm.params.variance_based_decomp = False + + elif dm.method == 'fsu_quasi_mc': + dm.type = 'dace' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.halton = False + dm.params.hammersley = False + dm.params.samples = 0 + dm.params.sequence_start = [0] + dm.params.sequence_leap = [1] + dm.params.prime_base = False + dm.params.fixed_sequence = False + dm.params.latinize = False + dm.params.variance_based_decomp = False + dm.params.quality_metrics = False + + elif dm.method == 'fsu_cvt': + dm.type = 'dace' + dm.variables = ['continuous_design', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.seed = False + dm.params.fixed_seed = False + dm.params.samples = 0 + dm.params.num_trials = 10000 + dm.params.trial_type = 'random' + dm.params.latinize = False + dm.params.variance_based_decomp = False + dm.params.quality_metrics = False + + elif dm.method == 'vector_parameter_study': + dm.type = 'param' + dm.variables = ['continuous_design', + 'normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.output = False + dm.params.final_point = [] + dm.params.step_length = [] + dm.params.num_steps = [] + dm.params.step_vector = [] + dm.params.num_steps = [] + + elif dm.method == 'list_parameter_study': + dm.type = 'param' + dm.variables = ['continuous_design', + 'normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.output = False + dm.params.list_of_points = [] + + elif dm.method == 'centered_parameter_study': + dm.type = 'param' + dm.variables = ['continuous_design', + 'normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.output = False + dm.params.percent_delta = [] + dm.params.deltas_per_variable = [] + + elif dm.method == 'multidim_parameter_study': + dm.type = 'param' + dm.variables = ['continuous_design', + 'normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function'] + dm.ghspec = [] + dm.params.output = False + dm.params.partitions = [] + + elif dm.method == 'bayes_calibration': + dm.type = 'bayes' + dm.variables = ['continuous_design', + 'normal_uncertain', + 'uniform_uncertain', + 'continuous_state'] + dm.lcspec = [] + dm.responses = ['objective_function', + 'response_function', + 'calibration_function'] + dm.ghspec = [] + dm.params.queso = False + dm.params.dream = False + dm.params.gpmsa = False + dm.params.samples = 0 + dm.params.seed = False + dm.params.output = False + dm.params.metropolis_hastings = False + dm.params.proposal_covariance = False + dm.params.diagonal = False + dm.params.values = [] + + else: + raise RuntimeError('Unimplemented method: {}.'.format(dm.method)) + + # if more than one argument, issue warning + else: + print('Warning: dakota_method:extra_arg: Extra arguments for object of class ' + str(type(dm)) + '.') + return dm + + def __repr__(dm): + + # display the object + string = '\nclass dakota_method object = \n' + string += ' method: ' + str(dm.method) + '\n' + string += ' type: ' + str(dm.type) + '\n' + string += ' variables: ' + str(dm.variables) + '\n' + string += ' lcspec: ' + str(dm.lcspec) + '\n' + string += ' responses: ' + str(dm.responses) + '\n' + string += ' ghspec: ' + str(dm.ghspec) + '\n' + + # display the parameters within the object + + fnames = fieldnames(dm.params) + #get rid of stuff we aren't using + try: + fnames.remove('__module__') + except ValueError: + pass + + maxlen = 0 + for i in range(len(fnames)): + maxlen = max(maxlen, len(fnames[i])) + + for i in fnames: + string += ' params.{:{space}s}: {}\n'.format(str(i), str(dm.params.__dict__[i]), space=maxlen + 1) + #params.x : y + #with maxlen + 1 spaces between x and : + return string Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_merge.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_merge.m (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_merge.m (revision 24532) @@ -0,0 +1,27 @@ +% +% merge a structure of parameters into a dakota_method object. +% +% [dm]=dmeth_params_merge(dm,params) +% +function [dm]=dmeth_params_merge(dm,params) + +if ~isa(dm,'dakota_method') + error('Object ''%s'' is a ''%s'' class object, not ''%s''.',... + inputname(1),class(dm),'dakota_method'); +end + +% loop through each parameter field in the structure + +fnames=fieldnames(params); + +for i=1:numel(fnames) + if isfield(dm.params,fnames{i}) + dm.params.(fnames{i})=params.(fnames{i}); + else + warning('dmeth_params_merge:unknown_param',... + 'No parameter ''%s'' for dakota_method ''%s''.',... + fnames{i},dm.method); + end +end + +end Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.m (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.m (revision 24532) @@ -0,0 +1,25 @@ +% +% set parameters of a dakota_method object. +% +% [dm]=dmeth_params_set(dm,varargin) +% +function [dm]=dmeth_params_set(dm,varargin) + +if ~isa(dm,'dakota_method') + error('Object ''%s'' is a ''%s'' class object, not ''%s''.',... + inputname(1),class(dm),'dakota_method'); +end + +% loop through each parameter field in the input list + +for i=1:2:length(varargin) + if isfield(dm.params,varargin{i}) + dm.params.(varargin{i})=varargin{i+1}; + else + warning('dmeth_params_set:unknown_param',... + 'No parameter ''%s'' for dakota_method ''%s''.',... + varargin{i},dm.method); + end +end + +end Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.py =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.py (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_set.py (revision 24532) @@ -0,0 +1,24 @@ +from helpers import * +from dakota_method import * + + +def dmeth_params_set(dm, *args): + # + # set parameters of a dakota_method object. + # + # dm = dmeth_params_set(dm, *args) + # + + if not isinstance(dm, dakota_method): + raise RuntimeError('Provided object is a \'' + str(type(dm)) + '\' class object, not \'dakota_method\'') + + # loop through each parameter field in the input list + for i in range(0, len(args), 2): + if isfield(dm.params, args[i]): + #vars(dresp)[fnames[i]] + exec(('dm.params.%s = args[i + 1]') % (args[i])) + #vars(dm.params)[args[i]] = args[i + 1] + else: + print('WARNING: dmeth_params_set:unknown_param No parameter \'' + str(args[i]) + '\' for dakota_method \'' + str(dm.method) + '\'.') + + return dm Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.m (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.m (revision 24532) @@ -0,0 +1,603 @@ +% +% write the parameters from a dakota_method object. +% +% []=dmeth_params_write(dm,fid,sbeg) +% +function []=dmeth_params_write(dm,fid,sbeg) + +if ~isa(dm,'dakota_method') + error('Object ''%s'' is a ''%s'' class object, not ''%s''.',... + inputname(1),class(dm),'dakota_method'); +end + +if ~exist('sbeg','var') + sbeg='\t '; +end + +% perform some error checking, but leave the rest to dakota. +% unfortunately this prevents merely looping through the fields +% of the parameters structure. + +% write method-independent controls + +% param_write(fid,sbeg,'id_method',' = ','\n',dm.params); +% param_write(fid,sbeg,'model_pointer',' = ','\n',dm.params); + +% write method-dependent controls + +switch dm.type + case {'dot'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case{'dot_bfgs',... + 'dot_frcg',... + 'dot_mmfd',... + 'dot_slp',... + 'dot_sqp'} + param_write(fid,sbeg,'optimization_type',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'npsol'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case {'npsol_sqp'} + param_write(fid,sbeg,'verify_level',' = ','\n',dm.params); + param_write(fid,sbeg,'function_precision',' = ','\n',dm.params); + param_write(fid,sbeg,'linesearch_tolerance',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'conmin'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case {'conmin_frcg',... + 'conmin_mfd'} + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'optpp'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case {'optpp_cg'} + param_write(fid,sbeg,'max_step',' = ','\n',dm.params); + param_write(fid,sbeg,'gradient_tolerance',' = ','\n',dm.params); + + case {'optpp_q_newton',... + 'optpp_fd_newton',... + 'optpp_newton'} + if (dm.params.value_based_line_search + ... + dm.params.gradient_based_line_search + ... + dm.params.trust_region + ... + dm.params.tr_pds > 1) + error('''%s'' method must have only one algorithm.',... + dm.method); + end + param_write(fid,sbeg,'value_based_line_search','','\n',dm.params); + param_write(fid,sbeg,'gradient_based_line_search','','\n',dm.params); + param_write(fid,sbeg,'trust_region','','\n',dm.params); + param_write(fid,sbeg,'tr_pds','','\n',dm.params); + param_write(fid,sbeg,'max_step',' = ','\n',dm.params); + param_write(fid,sbeg,'gradient_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'merit_function',' = ','\n',dm.params); + param_write(fid,sbeg,'central_path',' = ','\n',dm.params); + param_write(fid,sbeg,'steplength_to_boundary',' = ','\n',dm.params); + param_write(fid,sbeg,'centering_parameter',' = ','\n',dm.params); + + case {'optpp_pds'} + param_write(fid,sbeg,'search_scheme_size',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'apps'} + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case {'asynch_pattern_search'} + param_write(fid,sbeg,'initial_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'threshold_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'contraction_factor',' = ','\n',dm.params); + param_write(fid,sbeg,'solution_target',' = ','\n',dm.params); + param_write(fid,sbeg,'synchronization',' = ','\n',dm.params); + param_write(fid,sbeg,'merit_function',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_penalty',' = ','\n',dm.params); + param_write(fid,sbeg,'smoothing_factor',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'coliny'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + + param_write(fid,sbeg,'show_misc_options','','\n',dm.params); + param_write(fid,sbeg,'misc_options',' = ','\n',dm.params); + param_write(fid,sbeg,'solution_accuracy',' = ','\n',dm.params); + switch dm.method + case {'coliny_cobyla'} + param_write(fid,sbeg,'initial_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'threshold_delta',' = ','\n',dm.params); + + case {'coliny_direct'} + param_write(fid,sbeg,'division',' = ','\n',dm.params); + param_write(fid,sbeg,'global_balance_parameter',' = ','\n',dm.params); + param_write(fid,sbeg,'local_balance_parameter',' = ','\n',dm.params); + param_write(fid,sbeg,'max_boxsize_limit',' = ','\n',dm.params); + param_write(fid,sbeg,'min_boxsize_limit',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_penalty',' = ','\n',dm.params); + + case {'coliny_ea'} + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'population_size',' = ','\n',dm.params); + param_write(fid,sbeg,'initialization_type',' = ','\n',dm.params); + param_write(fid,sbeg,'fitness_type',' = ','\n',dm.params); + param_write(fid,sbeg,'replacement_type',' = ','\n',dm.params); + param_write(fid,sbeg,'random',' = ','\n',dm.params); + param_write(fid,sbeg,'chc',' = ','\n',dm.params); + param_write(fid,sbeg,'elitist',' = ','\n',dm.params); + param_write(fid,sbeg,'new_solutions_generated',' = ','\n',dm.params); + param_write(fid,sbeg,'crossover_type',' = ','\n',dm.params); + param_write(fid,sbeg,'crossover_rate',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_type',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_scale',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_range',' = ','\n',dm.params); + param_write(fid,sbeg,'dimension_ratio',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_rate',' = ','\n',dm.params); + param_write(fid,sbeg,'non_adaptive','','\n',dm.params); + + case {'coliny_pattern_search'} + param_write(fid,sbeg,'stochastic','','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'initial_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'threshold_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_penalty',' = ','\n',dm.params); + param_write(fid,sbeg,'constant_penalty','','\n',dm.params); + param_write(fid,sbeg,'pattern_basis',' = ','\n',dm.params); + param_write(fid,sbeg,'total_pattern_size',' = ','\n',dm.params); + param_write(fid,sbeg,'no_expansion','','\n',dm.params); + param_write(fid,sbeg,'expand_after_success',' = ','\n',dm.params); + param_write(fid,sbeg,'contraction_factor',' = ','\n',dm.params); + param_write(fid,sbeg,'synchronization',' = ','\n',dm.params); + param_write(fid,sbeg,'exploratory_moves',' = ','\n',dm.params); + + case {'coliny_solis_wets'} + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'initial_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'threshold_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'no_expansion','','\n',dm.params); + param_write(fid,sbeg,'expand_after_success',' = ','\n',dm.params); + param_write(fid,sbeg,'contract_after_failure',' = ','\n',dm.params); + param_write(fid,sbeg,'contraction_factor',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_penalty',' = ','\n',dm.params); + param_write(fid,sbeg,'constant_penalty','','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'ncsu'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + switch dm.method + case {'ncsu_direct'} + param_write(fid,sbeg,'solution_accuracy',' = ','\n',dm.params); + param_write(fid,sbeg,'min_boxsize_limit',' = ','\n',dm.params); + param_write(fid,sbeg,'vol_boxsize_limit',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'jega'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'log_file',' = ','\n',dm.params); + param_write(fid,sbeg,'population_size',' = ','\n',dm.params); + param_write(fid,sbeg,'print_each_pop','','\n',dm.params); + param_write(fid,sbeg,'output',' = ','\n',dm.params); + param_write(fid,sbeg,'initialization_type',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_type',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_scale',' = ','\n',dm.params); + param_write(fid,sbeg,'mutation_rate',' = ','\n',dm.params); + param_write(fid,sbeg,'replacement_type',' = ','\n',dm.params); + param_write(fid,sbeg,'below_limit',' = ','\n',dm.params); + param_write(fid,sbeg,'shrinkage_percentage',' = ','\n',dm.params); + param_write(fid,sbeg,'crossover_type',' = ','\n',dm.params); + param_write(fid,sbeg,'multi_point_binary',' = ','\n',dm.params); + param_write(fid,sbeg,'multi_point_parameterized_binary',' = ','\n',dm.params); + param_write(fid,sbeg,'multi_point_real',' = ','\n',dm.params); + param_write(fid,sbeg,'shuffle_random',' = ','\n',dm.params); + param_write(fid,sbeg,'num_parents',' = ','\n',dm.params); + param_write(fid,sbeg,'num_offspring',' = ','\n',dm.params); + param_write(fid,sbeg,'crossover_rate',' = ','\n',dm.params); + + switch dm.method + case {'moga'} + param_write(fid,sbeg,'fitness_type',' = ','\n',dm.params); + param_write(fid,sbeg,'niching_type',' = ','\n',dm.params); + if ~isempty(dm.params.radial) && ... + ~isempty(dm.params.distance) + error('''%s'' method must have only one niching distance.',... + dm.method); + end + param_write(fid,sbeg,'radial',' = ','\n',dm.params); + param_write(fid,sbeg,'distance',' = ','\n',dm.params); + param_write(fid,sbeg,'metric_tracker','','\n',dm.params); + param_write(fid,sbeg,'percent_change',' = ','\n',dm.params); + param_write(fid,sbeg,'num_generations',' = ','\n',dm.params); + param_write(fid,sbeg,'postprocessor_type',' = ','\n',dm.params); + param_write(fid,sbeg,'orthogonal_distance',' = ','\n',dm.params); + + case {'soga'} + param_write(fid,sbeg,'fitness_type',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_penalty',' = ','\n',dm.params); + param_write(fid,sbeg,'replacement_type',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_type',' = ','\n',dm.params); + param_write(fid,sbeg,'num_generations',' = ','\n',dm.params); + param_write(fid,sbeg,'percent_change',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'lsq'} + switch dm.method + case {'nl2sol'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + + param_write(fid,sbeg,'function_precision',' = ','\n',dm.params); + param_write(fid,sbeg,'absolute_conv_tol',' = ','\n',dm.params); + param_write(fid,sbeg,'x_conv_tol',' = ','\n',dm.params); + param_write(fid,sbeg,'singular_conv_tol',' = ','\n',dm.params); + param_write(fid,sbeg,'singular_radius',' = ','\n',dm.params); + param_write(fid,sbeg,'false_conv_tol',' = ','\n',dm.params); + param_write(fid,sbeg,'initial_trust_radius',' = ','\n',dm.params); + param_write(fid,sbeg,'covariance',' = ','\n',dm.params); + param_write(fid,sbeg,'regression_stressbalances','','\n',dm.params); + + case {'nlssol_sqp'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'constraint_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + + param_write(fid,sbeg,'verify_level',' = ','\n',dm.params); + param_write(fid,sbeg,'function_precision',' = ','\n',dm.params); + param_write(fid,sbeg,'linesearch_tolerance',' = ','\n',dm.params); + + case {'optpp_g_newton'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'max_function_evaluations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' ','\n',dm.params); + param_write(fid,sbeg,'speculative','','\n',dm.params); + param_write(fid,sbeg,'scaling','','\n',dm.params); + + if (dm.params.value_based_line_search + ... + dm.params.gradient_based_line_search + ... + dm.params.trust_region + ... + dm.params.tr_pds > 1) + error('''%s'' method must have only one algorithm.',... + dm.method); + end + param_write(fid,sbeg,'value_based_line_search','','\n',dm.params); + param_write(fid,sbeg,'gradient_based_line_search','','\n',dm.params); + param_write(fid,sbeg,'trust_region','','\n',dm.params); + param_write(fid,sbeg,'tr_pds','','\n',dm.params); + param_write(fid,sbeg,'max_step',' = ','\n',dm.params); + param_write(fid,sbeg,'gradient_tolerance',' = ','\n',dm.params); + param_write(fid,sbeg,'merit_function',' = ','\n',dm.params); + param_write(fid,sbeg,'central_path',' = ','\n',dm.params); + param_write(fid,sbeg,'steplength_to_boundary',' = ','\n',dm.params); + param_write(fid,sbeg,'centering_parameter',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'nond'} + switch dm.method + case {'nond_sampling'} + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_seed','','\n',dm.params); + dver=textscan(IssmConfig('_DAKOTA_VERSION_'),'%[0123456789].%[0123456789].%[0123456789]'); + if ((str2num(dver{1}{1})==4 && str2num(dver{2}{1})>2) || str2num(dver{1}{1})>4) + param_write(fid,sbeg,'rng',' ','\n',dm.params); + end + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'sample_type',' ','\n',dm.params); + param_write(fid,sbeg,'all_variables','','\n',dm.params); + param_write(fid,sbeg,'variance_based_decomp','','\n',dm.params); + if strcmp(dm.params.sample_type,'incremental_random') || ... + strcmp(dm.params.sample_type,'incremental_lhs' ) + param_write(fid,sbeg,'previous_samples',' = ','\n',dm.params); + end + param_write(fid,sbeg,'output',' ','\n',dm.params); + + case {'nond_local_reliability'} + param_write(fid,sbeg,'max_iterations',' = ','\n',dm.params); + param_write(fid,sbeg,'convergence_tolerance',' = ','\n',dm.params); + + param_write(fid,sbeg,'mpp_search',' = ','\n',dm.params); + if ischar(dm.params.mpp_search) + if (dm.params.sqp + ... + dm.params.nip > 1) + error('''%s'' method must have only one algorithm.',... + dm.method); + end + param_write(fid,sbeg,'sqp','','\n',dm.params); + param_write(fid,sbeg,'nip','','\n',dm.params); + param_write(fid,sbeg,'integration',' ','\n',dm.params); + param_write(fid,sbeg,'refinement',' = ','\n',dm.params); + if ischar(dm.params.refinement) + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + end + end + param_write(fid,sbeg,'output',' ','\n',dm.params); + + case {'nond_global_reliability'} + if (dm.params.x_gaussian_process + ... + dm.params.u_gaussian_process ~= 1) + error('''%s'' method must have one and only one algorithm.',... + dm.method); + end + param_write(fid,sbeg,'x_gaussian_process','','\n',dm.params); + param_write(fid,sbeg,'u_gaussian_process','','\n',dm.params); + param_write(fid,sbeg,'all_variables','','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + + case {'nond_polynomial_chaos'} + param_write(fid,sbeg,'expansion_order',' = ','\n',dm.params); + param_write(fid,sbeg,'expansion_terms',' = ','\n',dm.params); + param_write(fid,sbeg,'quadrature_order',' = ','\n',dm.params); + param_write(fid,sbeg,'sparse_grid_level',' = ','\n',dm.params); + param_write(fid,sbeg,'expansion_samples',' = ','\n',dm.params); + param_write(fid,sbeg,'incremental_lhs','','\n',dm.params); + param_write(fid,sbeg,'collocation_points',' = ','\n',dm.params); + param_write(fid,sbeg,'collocation_ratio',' = ','\n',dm.params); + param_write(fid,sbeg,'reuse_samples','','\n',dm.params); + param_write(fid,sbeg,'expansion_import_file',' = ','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_seed','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'sample_type',' = ','\n',dm.params); + param_write(fid,sbeg,'all_variables','','\n',dm.params); + + case {'nond_stoch_collocation'} + param_write(fid,sbeg,'quadrature_order',' = ','\n',dm.params); + param_write(fid,sbeg,'sparse_grid_level',' = ','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_seed','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'sample_type',' = ','\n',dm.params); + param_write(fid,sbeg,'all_variables','','\n',dm.params); + + case {'nond_evidence'} + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'dace'} + switch dm.method + case {'dace'} + if (dm.params.grid + ... + dm.params.random + ... + dm.params.oas + ... + dm.params.lhs + ... + dm.params.oa_lhs + ... + dm.params.box_behnken + ... + dm.params.central_composite ~= 1) + error('''%s'' method must have one and only one algorithm.',... + dm.method); + end + param_write(fid,sbeg,'grid','','\n',dm.params); + param_write(fid,sbeg,'random','','\n',dm.params); + param_write(fid,sbeg,'oas','','\n',dm.params); + param_write(fid,sbeg,'lhs','','\n',dm.params); + param_write(fid,sbeg,'oa_lhs','','\n',dm.params); + param_write(fid,sbeg,'box_behnken','','\n',dm.params); + param_write(fid,sbeg,'central_composite','','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_seed','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'symbols',' = ','\n',dm.params); + param_write(fid,sbeg,'quality_metrics','','\n',dm.params); + param_write(fid,sbeg,'variance_based_decomp','','\n',dm.params); + + case {'fsu_quasi_mc'} + if (dm.params.halton + ... + dm.params.hammersley ~= 1) + error('''%s'' method must have one and only one sequence type.',... + dm.method); + end + param_write(fid,sbeg,'halton','','\n',dm.params); + param_write(fid,sbeg,'hammersley','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'sequence_start',' = ','\n',dm.params); + param_write(fid,sbeg,'sequence_leap',' = ','\n',dm.params); + param_write(fid,sbeg,'prime_base',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_sequence','','\n',dm.params); + param_write(fid,sbeg,'latinize','','\n',dm.params); + param_write(fid,sbeg,'variance_based_decomp','','\n',dm.params); + param_write(fid,sbeg,'quality_metrics','','\n',dm.params); + + case {'fsu_cvt'} + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'fixed_seed','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'num_trials',' = ','\n',dm.params); + param_write(fid,sbeg,'trial_type',' = ','\n',dm.params); + param_write(fid,sbeg,'latinize','','\n',dm.params); + param_write(fid,sbeg,'variance_based_decomp','','\n',dm.params); + param_write(fid,sbeg,'quality_metrics','','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'param'} + param_write(fid,sbeg,'output',' ','\n',dm.params); + switch dm.method + case {'vector_parameter_study'} + if ~xor(isempty(dm.params.final_point), ... + isempty(dm.params.step_vector)) + error('''%s'' method must have one and only one specification.',... + dm.method); + end + if ~isempty(dm.params.final_point) + param_write(fid,sbeg,'final_point',' = ','\n',dm.params); + param_write(fid,sbeg,'step_length',' = ','\n',dm.params); + param_write(fid,sbeg,'num_steps',' = ','\n',dm.params); + elseif ~isempty(dm.params.step_vector) + param_write(fid,sbeg,'step_vector',' = ','\n',dm.params); + param_write(fid,sbeg,'num_steps',' = ','\n',dm.params); + end + + case {'list_parameter_study'} + param_write(fid,sbeg,'list_of_points',' = ','\n',dm.params); + + case {'centered_parameter_study'} + param_write(fid,sbeg,'percent_delta',' = ','\n',dm.params); + param_write(fid,sbeg,'deltas_per_variable',' = ','\n',dm.params); + + case {'multidim_parameter_study'} + param_write(fid,sbeg,'partitions',' = ','\n',dm.params); + + otherwise + error('Unrecognized ''%s'' method: ''%s''.',dm.type,dm.method); + end + + case {'bayes'} + switch dm.method + case {'bayes_calibration'} + % if (dm.params.queso + ... + % dm.params.dream + ... + % dm.params.gpmsa ~= 1) + % error('''%s'' method must have one and only one bayes type. YOU SUCK',... + % dm.method); + % end + param_write(fid,sbeg,'queso','','\n',dm.params); + param_write(fid,sbeg,'dream','','\n',dm.params); + param_write(fid,sbeg,'gpmsa','','\n',dm.params); + param_write(fid,sbeg,'samples',' = ','\n',dm.params); + param_write(fid,sbeg,'seed',' = ','\n',dm.params); + param_write(fid,sbeg,'output',' =','\n',dm.params); + param_write(fid,sbeg,'metropolis_hastings','','\n',dm.params); + param_write(fid,sbeg,'proposal_covariance','','\n',dm.params); + param_write(fid,sbeg,'diagonal','','\n',dm.params); + param_write(fid,sbeg,'values',' = ','\n',dm.params); + end + + otherwise + error('Unrecognized method type: ''%s''.',dm.type); +end + +end + +%% function to write a structure of parameters + +function []=param_struc_write(fidi,sbeg,smid,send,params) + +% loop through each parameter field in the structure + +fnames=fieldnames(params); + +for i=1:numel(fnames) + param_write(fidi,sbeg,fnames{i},smid,send,params); +end + +end + +%% function to write a parameter + +function []=param_write(fidi,sbeg,pname,smid,send,params) + +% check for errors + +if ~isfield(params,pname) + warning('param_write:param_not_found',... + 'Parameter ''%s'' not found in ''%s''.',... + pname,inputname(6)); + return +elseif islogical(params.(pname)) && ~params.(pname) + return +elseif isempty(params.(pname)) + warning('param_write:param_empty',... + 'Parameter ''%s'' requires input of type ''%s''.',... + pname,class(params.(pname))); + return +end + +% construct the parameter string based on type + +if islogical(params.(pname)) + fprintf(fidi,[sbeg '%s' send],pname); +elseif isnumeric(params.(pname)) + fprintf(fidi,[sbeg '%s' smid '%g'],pname,params.(pname)(1)); + for i=2:numel(params.(pname)) + fprintf(fidi,[' %g'],params.(pname)(i)); + end + fprintf(fidi,[send]); +elseif ischar (params.(pname)) + fprintf(fidi,[sbeg '%s' smid '%s' send],pname,params.(pname)); +else + warning('param_write:param_unrecog',... + 'Parameter ''%s'' is of unrecognized type ''%s''.',... + pname,class(params.(pname))); + return +end + +end Index: /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.py =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.py (revision 24532) +++ /issm/trunk-jpl/src/m/classes/qmu/dakota_method/dmeth_params_write.py (revision 24532) @@ -0,0 +1,538 @@ +from dakota_method import * +from MatlabFuncs import * +from IssmConfig import * +#move this later: +from helpers import * + + +def dmeth_params_write(dm, fid, sbeg='\t '): + ''' write the parameters from a dakota_method object. + [] = dmeth_params_write(dm, fid, sbeg) + ''' + + if not isinstance(dm, dakota_method): + raise RuntimeError('Object ' + str(dm) + ' is a ' + type(dm) + ' class object, not < dakota_method > .') + + if sbeg is None or sbeg == '': + sbeg = '\t ' + + # perform some error checking, but leave the rest to dakota. + # unfortunately this prevents merely looping through the fields + # of the parameters structure. + + # write method - indepent controls + + # param_write(fid, sbeg, 'id_method', ' = ', '\n', dm.params) + # param_write(fid, sbeg, 'model_pointer', ' = ', '\n', dm.params) + + # write method - depent controls + + #switch dm.type + if dm.type == 'dot': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method in ['dot_bfgs', + 'dot_frcg', + 'dot_mmfd', + 'dot_slp', + 'dot_sqp']: + param_write(fid, sbeg, 'optimization_type', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'npsol': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method == 'npsol_sqp': + param_write(fid, sbeg, 'verify_level', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'function_precision', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'linesearch_tolerance', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'conmin': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method in ['conmin_frcg', 'conmin_mfd']: + pass + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'optpp': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method == 'optpp_cg': + param_write(fid, sbeg, 'max_step', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'gradient_tolerance', ' = ', '\n', dm.params) + + elif dm.method in ['optpp_q_newton', 'optpp_fd_newton', 'optpp_newton']: + if (dm.params.value_based_line_search + dm.params.gradient_based_line_search + dm.params.trust_region + dm.params.tr_pds > 1): + raise RuntimeError(' #s'' method must have only one algorithm.', dm.method) + param_write(fid, sbeg, 'value_based_line_search', '', '\n', dm.params) + param_write(fid, sbeg, 'gradient_based_line_search', '', '\n', dm.params) + param_write(fid, sbeg, 'trust_region', '', '\n', dm.params) + param_write(fid, sbeg, 'tr_pds', '', '\n', dm.params) + param_write(fid, sbeg, 'max_step', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'gradient_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'merit_function', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'central_path', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'steplength_to_boundary', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'centering_parameter', ' = ', '\n', dm.params) + + elif dm.method == 'optpp_pds': + param_write(fid, sbeg, 'search_scheme_size', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'apps': + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method == 'asynch_pattern_search': + param_write(fid, sbeg, 'initial_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'threshold_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'contraction_factor', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'solution_target', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'synchronization', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'merit_function', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_penalty', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'smoothing_factor', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'coliny': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + param_write(fid, sbeg, 'show_misc_options', '', '\n', dm.params) + param_write(fid, sbeg, 'misc_options', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'solution_accuracy', ' = ', '\n', dm.params) + #switch dm.method + if dm.method == 'coliny_cobyla': + param_write(fid, sbeg, 'initial_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'threshold_delta', ' = ', '\n', dm.params) + + elif dm.method == 'coliny_direct': + param_write(fid, sbeg, 'division', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'global_balance_parameter', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'local_balance_parameter', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_boxsize_limit', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'min_boxsize_limit', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_penalty', ' = ', '\n', dm.params) + + elif dm.method == 'coliny_ea': + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'population_size', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'initialization_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fitness_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'replacement_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'random', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'chc', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'elitist', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'new_solutions_generated', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'crossover_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'crossover_rate', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_scale', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_range', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'dimension_ratio', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_rate', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'non_adaptive', '', '\n', dm.params) + + elif dm.method == 'coliny_pattern_search': + param_write(fid, sbeg, 'stochastic', '', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'initial_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'threshold_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_penalty', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constant_penalty', '', '\n', dm.params) + param_write(fid, sbeg, 'pattern_basis', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'total_pattern_size', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'no_expansion', '', '\n', dm.params) + param_write(fid, sbeg, 'expand_after_success', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'contraction_factor', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'synchronization', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'exploratory_moves', ' = ', '\n', dm.params) + + elif dm.method == 'coliny_solis_wets': + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'initial_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'threshold_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'no_expansion', '', '\n', dm.params) + param_write(fid, sbeg, 'expand_after_success', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'contract_after_failure', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'contraction_factor', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_penalty', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constant_penalty', '', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'ncsu': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + #switch dm.method + if dm.method == 'ncsu_direct': + param_write(fid, sbeg, 'solution_accuracy', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'min_boxsize_limit', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'vol_boxsize_limit', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'jega': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'log_file', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'population_size', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'print_each_pop', '', '\n', dm.params) + param_write(fid, sbeg, 'output', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'initialization_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_scale', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mutation_rate', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'replacement_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'below_limit', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'shrinkage_percentage', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'crossover_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'multi_point_binary', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'multi_point_parameterized_binary', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'multi_point_real', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'shuffle_random', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_parents', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_offspring', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'crossover_rate', ' = ', '\n', dm.params) + + #switch dm.method + if dm.method == 'moga': + param_write(fid, sbeg, 'fitness_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'niching_type', ' = ', '\n', dm.params) + if not isempty(dm.params.radial) and not isempty(dm.params.distance): + raise RuntimeError(' #s'' method must have only one niching distance.', dm.method) + param_write(fid, sbeg, 'radial', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'distance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'metric_tracker', '', '\n', dm.params) + param_write(fid, sbeg, 'percent_change', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_generations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'postprocessor_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'orthogonal_distance', ' = ', '\n', dm.params) + + elif dm.method == 'soga': + param_write(fid, sbeg, 'fitness_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_penalty', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'replacement_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_generations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'percent_change', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'lsq': + #switch dm.method + if dm.method == 'nl2sol': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + param_write(fid, sbeg, 'function_precision', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'absolute_conv_tol', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'x_conv_tol', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'singular_conv_tol', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'singular_radius', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'false_conv_tol', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'initial_trust_radius', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'covariance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'regression_stressbalances', '', '\n', dm.params) + + elif dm.method == 'nlssol_sqp': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'constraint_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + param_write(fid, sbeg, 'verify_level', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'function_precision', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'linesearch_tolerance', ' = ', '\n', dm.params) + + elif dm.method == 'optpp_g_newton': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'max_function_evaluations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + param_write(fid, sbeg, 'speculative', '', '\n', dm.params) + param_write(fid, sbeg, 'scaling', '', '\n', dm.params) + + if (dm.params.value_based_line_search + dm.params.gradient_based_line_search + dm.params.trust_region + dm.params.tr_pds > 1): + raise RuntimeError(' #s'' method must have only one algorithm.', dm.method) + + param_write(fid, sbeg, 'value_based_line_search', '', '\n', dm.params) + param_write(fid, sbeg, 'gradient_based_line_search', '', '\n', dm.params) + param_write(fid, sbeg, 'trust_region', '', '\n', dm.params) + param_write(fid, sbeg, 'tr_pds', '', '\n', dm.params) + param_write(fid, sbeg, 'max_step', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'gradient_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'merit_function', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'central_path', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'steplength_to_boundary', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'centering_parameter', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'nond': + #switch dm.method + if dm.method == 'nond_sampling': + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_seed', '', '\n', dm.params) + dver = str(IssmConfig('_DAKOTA_VERSION_')[0]) + if ((int(dver[0]) == 4 and int(dver[2]) > 2) or int(dver[0]) > 4): + param_write(fid, sbeg, 'rng', ' ', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sample_type', ' ', '\n', dm.params) + param_write(fid, sbeg, 'all_variables', '', '\n', dm.params) + param_write(fid, sbeg, 'variance_based_decomp', '', '\n', dm.params) + if strcmp(dm.params.sample_type, 'incremental_random') or strcmp(dm.params.sample_type, 'incremental_lhs'): + param_write(fid, sbeg, 'previous_samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + + elif dm.method == 'nond_local_reliability': + param_write(fid, sbeg, 'max_iterations', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'convergence_tolerance', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'mpp_search', ' = ', '\n', dm.params) + if type(dm.params.mpp_search) == str: + if (dm.params.sqp + dm.params.nip > 1): + raise RuntimeError(' #s'' method must have only one algorithm.', dm.method) + + param_write(fid, sbeg, 'sqp', '', '\n', dm.params) + param_write(fid, sbeg, 'nip', '', '\n', dm.params) + param_write(fid, sbeg, 'integration', ' ', '\n', dm.params) + param_write(fid, sbeg, 'refinement', ' = ', '\n', dm.params) + if type(dm.params.refinement) == str: + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + + elif dm.method == 'nond_global_reliability': + if (dm.params.x_gaussian_process + dm.params.u_gaussian_process != 1): + raise RuntimeError(' #s'' method must have one and only one algorithm.', dm.method) + + param_write(fid, sbeg, 'x_gaussian_process', '', '\n', dm.params) + param_write(fid, sbeg, 'u_gaussian_process', '', '\n', dm.params) + param_write(fid, sbeg, 'all_variables', '', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + + elif dm.method == 'nond_polynomial_chaos': + param_write(fid, sbeg, 'expansion_order', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'expansion_terms', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'quadrature_order', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sparse_grid_level', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'expansion_samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'incremental_lhs', '', '\n', dm.params) + param_write(fid, sbeg, 'collocation_points', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'collocation_ratio', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'reuse_samples', '', '\n', dm.params) + param_write(fid, sbeg, 'expansion_import_file', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_seed', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sample_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'all_variables', '', '\n', dm.params) + + elif dm.method == 'nond_stoch_collocation': + param_write(fid, sbeg, 'quadrature_order', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sparse_grid_level', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_seed', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sample_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'all_variables', '', '\n', dm.params) + + elif dm.method == 'nond_evidence': + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'dace': + #switch dm.method + if dm.method == 'dace': + if (dm.params.grid + dm.params.random + dm.params.oas + dm.params.lhs + dm.params.oa_lhs + dm.params.box_behnken + dm.params.central_composite != 1): + raise RuntimeError(' #s'' method must have one and only one algorithm.', dm.method) + + param_write(fid, sbeg, 'grid', '', '\n', dm.params) + param_write(fid, sbeg, 'random', '', '\n', dm.params) + param_write(fid, sbeg, 'oas', '', '\n', dm.params) + param_write(fid, sbeg, 'lhs', '', '\n', dm.params) + param_write(fid, sbeg, 'oa_lhs', '', '\n', dm.params) + param_write(fid, sbeg, 'box_behnken', '', '\n', dm.params) + param_write(fid, sbeg, 'central_composite', '', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_seed', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'symbols', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'quality_metrics', '', '\n', dm.params) + param_write(fid, sbeg, 'variance_based_decomp', '', '\n', dm.params) + + elif dm.method == 'fsu_quasi_mc': + if (dm.params.halton + dm.params.hammersley != 1): + raise RuntimeError(' #s'' method must have one and only one sequence type.', dm.method) + + param_write(fid, sbeg, 'halton', '', '\n', dm.params) + param_write(fid, sbeg, 'hammersley', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sequence_start', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'sequence_leap', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'prime_base', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_sequence', '', '\n', dm.params) + param_write(fid, sbeg, 'latinize', '', '\n', dm.params) + param_write(fid, sbeg, 'variance_based_decomp', '', '\n', dm.params) + param_write(fid, sbeg, 'quality_metrics', '', '\n', dm.params) + + elif dm.method == 'fsu_cvt': + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'fixed_seed', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_trials', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'trial_type', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'latinize', '', '\n', dm.params) + param_write(fid, sbeg, 'variance_based_decomp', '', '\n', dm.params) + param_write(fid, sbeg, 'quality_metrics', '', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'param': + param_write(fid, sbeg, 'output', ' ', '\n', dm.params) + #switch dm.method + if dm.method == 'vector_parameter_study': + if not np.logical_xor(isempty(dm.params.final_point), isempty(dm.params.step_vector)): + raise RuntimeError(str(dm.method) + ' method must have one and only one specification.') + + if not isempty(dm.params.final_point): + param_write(fid, sbeg, 'final_point', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'step_length', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_steps', ' = ', '\n', dm.params) + + elif not isempty(dm.params.step_vector): + param_write(fid, sbeg, 'step_vector', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'num_steps', ' = ', '\n', dm.params) + + elif dm.method == 'list_parameter_study': + param_write(fid, sbeg, 'list_of_points', ' = ', '\n', dm.params) + + elif dm.method == 'centered_parameter_study': + param_write(fid, sbeg, 'percent_delta', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'deltas_per_variable', ' = ', '\n', dm.params) + + elif dm.method == 'multidim_parameter_study': + param_write(fid, sbeg, 'partitions', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + elif dm.type == 'bayes': + #switch dm.method + if dm.method == 'bayes_calibration': + # if (dm.params.queso + + # dm.params.dream + + # dm.params.gpmsa ~= 1) + # raise RuntimeError(''' #s'' method must have one and only one bayes type. YOU SUCK', + # dm.method) + # + param_write(fid, sbeg, 'queso', '', '\n', dm.params) + param_write(fid, sbeg, 'dream', '', '\n', dm.params) + param_write(fid, sbeg, 'gpmsa', '', '\n', dm.params) + param_write(fid, sbeg, 'samples', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'seed', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'output', ' = ', '\n', dm.params) + param_write(fid, sbeg, 'metropolis_hastings', '', '\n', dm.params) + param_write(fid, sbeg, 'proposal_covariance', '', '\n', dm.params) + param_write(fid, sbeg, 'diagonal', '', '\n', dm.params) + param_write(fid, sbeg, 'values', ' = ', '\n', dm.params) + + else: + raise RuntimeError('Unrecognized ' + dm.type + ' method: ' + dm.method + '.') + + +# function to write a structure of parameters +def param_struc_write(fidi, sbeg, smid, s, params): + # loop through each parameter field in the structure + fnames = fieldnames(params) + for i in range(np.size(fnames)): + param_write(fidi, sbeg, fnames[i], smid, s, params) + + return + + +# function to write a parameter +def param_write(fidi, sbeg, pname, smid, s, params): + # check for errors + if not isfield(params, pname): + warning('param_write:param_not_found', 'Parameter ' + str(pname) + ' not found in ' + params + '.') + return + elif type(vars(params)[pname]) == bool and not vars(params)[pname]: + return + elif isempty(vars(params)[pname]): + print('Warning: param_write:param_empty: Parameter {} requires input of type {}.'.format(pname, type(vars(params)[pname]))) + return + + # construct the parameter string based on type + if type(vars(params)[pname]) == bool: + fidi.write(sbeg + str(pname) + s) + + elif type(vars(params)[pname]) in [int, float]: + fidi.write(sbeg + str(pname) + smid + str(vars(params)[pname]) + s) + + elif type(vars(params)[pname]) == list: + fidi.write(sbeg + str(pname) + smid + str(vars(params)[pname][0])) + for i in range(1, np.size(vars(params)[pname])): + fidi.write(' ' + str(vars(params)[pname][i])) + + fidi.write(s) + + elif type(vars(params)[pname]) == str: + fidi.write(sbeg + str(pname) + smid + str(vars(params)[pname]) + s) + + else: + print('Warning: param_write:param_unrecog: Parameter {} is of unrecognized type {}.'.format(pname, type(vars(params)[pname]))) + return