Ignore:
Timestamp:
02/23/10 15:30:16 (15 years ago)
Author:
jschierm
Message:

Dakota: major update to Matlab interface scripts.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/m/solutions/dakota/dakota_in_write.m

    r2166 r3092  
    22%  write a Dakota .in input file.
    33%
    4 %  []=dakota_in_write(method,dmeth,dvar,dresp,params,filei,varargin)
     4%  []=dakota_in_write(method,dvar,dresp,params,filei,varargin)
     5%  []=dakota_in_write(dmeth ,dvar,dresp,params,filei,varargin)
    56%
    67%  where the required input is:
    … …  
    1213%    filei         (character, name of .in file)
    1314%
    14 %  the method, dmeth, and filei will be prompted if empty.
    15 %  params may be empty, in which case defaults will be used.
     15%  the method and filei will be prompted if empty.  params
     16%  may be empty, in which case defaults will be used.
    1617%
    1718%  the optional varargin are not yet used.
    … …  
    3031%  acknowledged. Any commercial use must be negotiated with
    3132%  the Office of Technology Transfer at the California Institute
    32 %  of Technology.  (NTR 47078)
     33%  of Technology.  (J. Schiermeier, NTR 47078)
    3334%
    3435%  This software may be subject to U.S. export control laws.
    … …  
    3940%  to foreign countries or providing access to foreign persons."
    4041%
    41 function []=dakota_in_write(method,dmeth,dvar,dresp,params,filei,varargin)
     42function []=dakota_in_write(method,dvar,dresp,params,filei,varargin)
    4243
    4344if ~nargin
    … …  
    5152    method=input('Method?  ','s');
    5253end
    53 
    54 if ~exist('dmeth' ,'var') || isempty(dmeth)
     54if     ischar(method)
    5555    dmeth=dakota_method(method);
     56elseif isa(method,'dakota_method')
     57    dmeth=method;
     58else
     59    error(['Method ''' inputname(1) ''' is unrecognized class ''' class(method) '''.']);
    5660end
    5761
    … …  
    134138%  write response levels
    135139
    136 if strcmp(dmeth.type,'nond') && isfield(dresp,'rf')
    137     param_write(fidi,'\t  ','distribution',' ','\n',params);
    138     [respl,probl,rell,grell]=prop_levels(dresp.rf);
    139     if ~isempty(respl)
    140         rlev_write(fidi,'response_levels',respl);
    141         param_write(fidi,'\t  ','compute',' ','\n',params);
    142     end
    143     if ~isempty(probl)
    144         rlev_write(fidi,'probability_levels',probl);
    145     end
    146     if ~isempty(rell)
    147         rlev_write(fidi,'reliability_levels',rell);
    148     end
    149     if ~isempty(grell)
    150         rlev_write(fidi,'gen_reliability_levels',grell);
    151     end
    152 end
    153 fprintf(fidi,'\n');
    154 
    155 end
    156 
    157 %%  function to write response levels
    158 
    159 function []=rlev_write(fidi,ltype,levels)
    160 
    161 fprintf(fidi,'\t  num_%s =',ltype);
    162 for i=1:length(levels)
    163     fprintf(fidi,' %d',length(levels{i}));
    164 end
    165 fprintf(fidi,'\n');
    166 
    167 fprintf(fidi,'\t  %s =\n',ltype);
    168 
    169 for i=1:length(levels)
    170     if ~isempty(levels{i})
    171         vector_write(fidi,sprintf('\t    '),levels{i},8,76);
    172     end
    173 end
     140if strcmp(dmeth.type,'nond')
     141    for i=1:length(dmeth.responses)
     142        fhresp=str2func([dmeth.responses{i} '.dakota_rlev_write']);
     143        fhresp(fidi,dresp,params);
     144    end
     145end
     146fprintf(fidi,'\n');
    174147
    175148end
    … …  
    196169%  variables vary by method
    197170
    198 vsets_write(fidi,dvar,dmeth.variables);
     171for i=1:length(dmeth.variables)
     172    fhvar=str2func([dmeth.variables{i} '.dakota_write']);
     173    fhvar(fidi,dvar);
     174end
    199175
    200176%  linear constraints vary by method
    201177
    202 lcsets_write(fidi,dvar,dmeth.lcspec);
    203 
    204 fprintf(fidi,'\n');
    205 
    206 end
    207 
    208 %%  function to write variable sets
    209 
    210 function []=vsets_write(fidi,dvar,variables)
    211 
    212 for i=1:length(variables)
    213     switch(variables{i})
    214         case 'cdv'
    215             cstring='continuous_design';
    216         case 'nuv'
    217             cstring='normal_uncertain';
    218         case 'csv'
    219             cstring='continuous_state';
    220         otherwise
    221             warning('vsets_write:unrec_var',...
    222                 'Unrecognized variable ''%s''.',variables{i});
    223     end
    224 
    225     if isfield(dvar,variables{i})
    226         vlist_write(fidi,cstring,variables{i},dvar.(variables{i}));
    227     end
    228 end
    229 
    230 end
    231 
    232 %%  function to write variable list
    233 
    234 function []=vlist_write(fidi,cstring,cstring2,dvar)
    235 
    236 %  put variables into lists for writing
    237 
    238 pinitpt=prop_initpt(dvar);
    239 plower =prop_lower (dvar);
    240 pupper =prop_upper (dvar);
    241 pmean  =prop_mean  (dvar);
    242 pstddev=prop_stddev(dvar);
    243 pinitst=prop_initst(dvar);
    244 pstype =prop_stype (dvar);
    245 pscale =prop_scale (dvar);
    246 pdesc  =prop_desc  (dvar);
    247 
    248 %  write variables
    249 %  (using Dakota 4.1 syntax for backward compatability)
    250 
    251 disp(sprintf('  Writing %d %s variables.',length(dvar),class(dvar)));
    252 
    253 fprintf(fidi,'\t%s = %d\n',cstring,length(dvar));
    254 if ~isempty(pinitpt)
    255     fprintf(fidi,'\t  %s_initial_point =\n',cstring2);
    256     vector_write(fidi,sprintf('\t    '),pinitpt,6,76);
    257 end
    258 if ~isempty(plower)
    259     fprintf(fidi,'\t  %s_lower_bounds =\n',cstring2);
    260     vector_write(fidi,sprintf('\t    '),plower ,6,76);
    261 end
    262 if ~isempty(pupper)
    263     fprintf(fidi,'\t  %s_upper_bounds =\n',cstring2);
    264     vector_write(fidi,sprintf('\t    '),pupper ,6,76);
    265 end
    266 if ~isempty(pmean)
    267     fprintf(fidi,'\t  %s_means =\n',cstring2);
    268     vector_write(fidi,sprintf('\t    '),pmean  ,6,76);
    269 end
    270 if ~isempty(pstddev)
    271     fprintf(fidi,'\t  %s_std_deviations =\n',cstring2);
    272     vector_write(fidi,sprintf('\t    '),pstddev,6,76);
    273 end
    274 if ~isempty(pinitst)
    275     fprintf(fidi,'\t  %s_initial_state =\n',cstring2);
    276     vector_write(fidi,sprintf('\t    '),pinitst,6,76);
    277 end
    278 if ~isempty(pstype)
    279     fprintf(fidi,'\t  %s_scale_types =\n',cstring2);
    280     vector_write(fidi,sprintf('\t    '),pstype ,6,76);
    281 end
    282 if ~isempty(pscale)
    283     fprintf(fidi,'\t  %s_scales =\n',cstring2);
    284     vector_write(fidi,sprintf('\t    '),pscale ,6,76);
    285 end
    286 if ~isempty(pdesc)
    287     fprintf(fidi,'\t  %s_descriptors =\n',cstring2);
    288     vector_write(fidi,sprintf('\t    '),pdesc  ,6,76);
    289 end
    290 
    291 end
    292 
    293 %%  function to write linear constraint sets
    294 
    295 function []=lcsets_write(fidi,dvar,lcspec)
    296 
    297 for i=1:length(lcspec)
    298     switch(lcspec{i})
    299         case 'lic'
    300             cstring ='linear_inequality_constraints';
    301             cstring2='linear_inequality';
    302         case 'lec'
    303             cstring ='linear_equality_constraints';
    304             cstring2='linear_equality';
    305         otherwise
    306             warning('lcspec_write:unrec_lcspec',...
    307                 'Unrecognized linear constraint ''%s''.',lcspec{i});
    308     end
    309    
    310     if isfield(dvar,lcspec{i})
    311         lclist_write(fidi,cstring,cstring2,dvar.(lcspec{i}));
    312     end
    313 end
    314 
    315 end
    316 
    317 %%  function to write linear constraint list
    318 
    319 function []=lclist_write(fidi,cstring,cstring2,dvar)
    320 
    321 %  put linear constraints into lists for writing
    322 
    323 pmatrix=prop_matrix(dvar);
    324 plower =prop_lower (dvar);
    325 pupper =prop_upper (dvar);
    326 ptarget=prop_target(dvar);
    327 pstype =prop_stype (dvar);
    328 pscale =prop_scale (dvar);
    329 
    330 %  write linear constraints
    331 
    332 disp(sprintf('  Writing %d %s linear constraints.',...
    333     length(dvar),class(dvar)));
    334 
    335 if ~isempty(pmatrix)
    336     fprintf(fidi,'\t  %s_matrix =\n',cstring2);
    337     vector_write(fidi,sprintf('\t    '),pmatrix,6,76);
    338 end
    339 if ~isempty(plower)
    340     fprintf(fidi,'\t  %s_lower_bounds =\n',cstring2);
    341     vector_write(fidi,sprintf('\t    '),plower ,6,76);
    342 end
    343 if ~isempty(pupper)
    344     fprintf(fidi,'\t  %s_upper_bounds =\n',cstring2);
    345     vector_write(fidi,sprintf('\t    '),pupper ,6,76);
    346 end
    347 if ~isempty(ptarget)
    348     fprintf(fidi,'\t  %s_targets =\n',cstring2);
    349     vector_write(fidi,sprintf('\t    '),ptarget,6,76);
    350 end
    351 if ~isempty(pstype)
    352     fprintf(fidi,'\t  %s_scale_types =\n',cstring2);
    353     vector_write(fidi,sprintf('\t    '),pstype ,6,76);
    354 end
    355 if ~isempty(pscale)
    356     fprintf(fidi,'\t  %s_scales =\n',cstring2);
    357     vector_write(fidi,sprintf('\t    '),pscale ,6,76);
    358 end
     178for i=1:length(dmeth.lcspec)
     179    fhvar=str2func([dmeth.lcspec{i}    '.dakota_write']);
     180    fhvar(fidi,dvar);
     181end
     182
     183fprintf(fidi,'\n');
    359184
    360185end
    … …  
    407232    param_write(fidi,'\t','direct','','\n',params);
    408233    param_write(fidi,'\t  ','analysis_driver','     = ''','''\n',params);
    409     [pathstr,name,ext,versn] = fileparts(params.analysis_components);
    410     if isempty(ext)
    411         ext='.m';
    412     end
    413     params.analysis_components=fullfile(pathstr,[name ext versn]);
    414     param_write(fidi,'\t  ','analysis_components',' = ''','''\n',params);
     234    if ~isempty(params.analysis_components)
     235        [pathstr,name,ext,versn] = fileparts(params.analysis_components);
     236        if isempty(ext)
     237            ext='.m';
     238        end
     239        params.analysis_components=fullfile(pathstr,[name ext versn]);
     240        param_write(fidi,'\t  ','analysis_components',' = ''','''\n',params);
     241    end
    415242    if ~isempty(params.input_filter)
    416243        param_write(fidi,'\t  ','input_filter','    = ''','''\n',params);
    … …  
    421248    param_write(fidi,'\t  ','failure_capture','   ','\n',params);
    422249    param_write(fidi,'\t  ','deactivate','        ','\n',params);
    423     param_write(fidi,'\t  ','output','        ','\n',params);
    424250    param_write(fidi,'\t  ','processors_per_analysis',' = ''','''\n',params);
    425251end
    … …  
    439265%  functions, gradients, and hessians vary by method
    440266
    441 rsets_write(fidi,dresp,dmeth.responses);
    442 ghspec_write(fidi,params,dmeth.ghspec);
    443 
    444 fprintf(fidi,'\n');
    445 
    446 end
    447 
    448 %%  function to write response sets
    449 
    450 function []=rsets_write(fidi,dresp,responses)
    451 
    452267rdesc={};
    453268
    454 for i=1:length(responses)
    455     switch(responses{i})
    456         case 'of'
    457             cstring ='objective_functions';
    458             cstring2='objective_function';
    459         case 'lst'
    460             cstring ='least_squares_terms';
    461             cstring2='least_squares_term';
    462         case 'nic'
    463             cstring ='nonlinear_inequality_constraints';
    464             cstring2='nonlinear_inequality';
    465         case 'nec'
    466             cstring ='nonlinear_equality_constraints';
    467             cstring2='nonlinear_equality';
    468         case 'rf'
    469             cstring ='response_functions';
    470             cstring2='response_function';
    471         otherwise
    472             warning('rsets_write:unrec_resp',...
    473                 'Unrecognized response ''%s''.',responses{i});
    474     end
    475    
    476     if isfield(dresp,responses{i})
    477         [rdesc]=rlist_write(fidi,cstring,cstring2,dresp.(responses{i}),rdesc);
    478     end
    479 end
    480 
    481 %  write response descriptors
     269for i=1:length(dmeth.responses)
     270    fhresp=str2func([dmeth.responses{i} '.dakota_write']);
     271    [rdesc]=fhresp(fidi,dresp,rdesc);
     272end
     273
     274%  write accumulated response descriptors for all response classes
    482275
    483276if ~isempty(rdesc)
    … …  
    486279end
    487280
    488 end
    489 
    490 %%  function to write response list
    491 
    492 function [rdesc]=rlist_write(fidi,cstring,cstring2,dresp,rdesc)
    493 
    494 %  put responses into lists for writing
    495 
    496 pstype =prop_stype (dresp);
    497 pscale =prop_scale (dresp);
    498 pweight=prop_weight(dresp);
    499 plower =prop_lower (dresp);
    500 pupper =prop_upper (dresp);
    501 ptarget=prop_target(dresp);
    502 
    503 %  accumulate descriptors into list for subsequent writing
    504 
    505 rdesc(end+1:end+numel(dresp))=prop_desc  (dresp);
    506 
    507 %  write responses
    508 
    509 disp(sprintf('  Writing %d %s responses.',length(dresp),class(dresp)));
    510 
    511 fprintf(fidi,'\tnum_%s = %d\n',cstring,length(dresp));
    512 if ~isempty(pstype)
    513     fprintf(fidi,'\t  %s_scale_types =\n',cstring2);
    514     vector_write(fidi,sprintf('\t    '),pstype ,6,76);
    515 end
    516 if ~isempty(pscale)
    517     fprintf(fidi,'\t  %s_scales =\n',cstring2);
    518     vector_write(fidi,sprintf('\t    '),pscale ,6,76);
    519 end
    520 if ~isempty(pweight)
    521     switch cstring2
    522         case 'objective_function'
    523             fprintf(fidi,'\t  %s_weights =\n','multi_objective');
    524             vector_write(fidi,sprintf('\t    '),pweight,6,76);
    525         case 'least_squares_term'
    526             fprintf(fidi,'\t  %s_weights =\n','least_squares');
    527             vector_write(fidi,sprintf('\t    '),pweight,6,76);
    528     end
    529 end
    530 if ~isempty(plower)
    531     fprintf(fidi,'\t  %s_lower_bounds =\n',cstring2);
    532     vector_write(fidi,sprintf('\t    '),plower ,6,76);
    533 end
    534 if ~isempty(pupper)
    535     fprintf(fidi,'\t  %s_upper_bounds =\n',cstring2);
    536     vector_write(fidi,sprintf('\t    '),pupper ,6,76);
    537 end
    538 if ~isempty(ptarget)
    539     fprintf(fidi,'\t  %s_targets =\n',cstring2);
    540     vector_write(fidi,sprintf('\t    '),ptarget,6,76);
    541 end
     281ghspec_write(fidi,params,dmeth.ghspec);
     282
     283fprintf(fidi,'\n');
    542284
    543285end
    … …  
    550292
    551293if find_string(ghspec,'grad')
     294    if     ~params.numerical_gradients && ~params.analytic_gradients
     295        params.numerical_gradients=true;
     296    elseif (params.numerical_gradients+params.analytic_gradients > 1)
     297        error('Too many gradients selected.')
     298    end
     299
    552300    if     params.numerical_gradients
    553301        param_write(fidi,'\t','numerical_gradients','','\n',params);
    … …  
    572320
    573321end
    574 
    575 %%  function to write a parameter
    576 
    577 function []=param_write(fidi,sbeg,pname,smid,send,params)
    578 
    579 if ~isfield(params,pname)
    580     warning('param_write:param_not_found',...
    581         'Parameter ''%s'' not found in structure.',pname);
    582     return
    583 end
    584 
    585 if islogical(params.(pname)) && ~params.(pname)
    586     return
    587 end
    588 
    589 if     islogical(params.(pname))
    590     fprintf(fidi,[sbeg '%s' send],pname);
    591 elseif ischar   (params.(pname))
    592     fprintf(fidi,[sbeg '%s' smid '%s' send],pname,params.(pname));
    593 elseif isnumeric(params.(pname))
    594     fprintf(fidi,[sbeg '%s' smid '%g' send],pname,params.(pname));
    595 end
    596 
    597 end
    598 
    599 %%  function to write a vector on multiple lines
    600 
    601 function []=vector_write(fidi,sbeg,vec,nmax,cmax)
    602 
    603 if ~exist('nmax','var') || isempty(nmax)
    604     nmax=Inf;
    605 end
    606 if ~exist('cmax','var') || isempty(cmax)
    607     cmax=Inf;
    608 end
    609 
    610 %  set up first iteration
    611 
    612 svec =[];
    613 nitem=nmax;
    614 lsvec=cmax;
    615 
    616 %  transpose vector from column-wise to row-wise
    617 
    618 vec=vec';
    619 
    620 %  assemble each line, flushing when necessary
    621 
    622 for i=1:numel(vec)
    623     if isnumeric(vec(i))
    624         sitem=sprintf('%g'    ,vec(i));
    625     else
    626         sitem=sprintf('''%s''',char(vec(i)));
    627     end
    628     nitem=nitem+1;
    629     lsvec=lsvec+1+length(sitem);
    630    
    631     if (nitem <= nmax) && (lsvec <= cmax)
    632         svec=[svec ' ' sitem];
    633     else
    634         if ~isempty(svec)
    635             fprintf(fidi,'%s\n',svec);
    636         end
    637         svec=[sbeg sitem];
    638         nitem=1;
    639         lsvec=length(svec);
    640     end
    641 end
    642 
    643 %  flush buffer at end, if necessary
    644 
    645 if ~isempty(svec)
    646     fprintf(fidi,'%s\n',svec);
    647 end
    648 
    649 end
Note: See TracChangeset for help on using the changeset viewer.