Changeset 780

Timestamp:

06/04/09 16:36:32 (16 years ago)

Author:

Eric.Larour

Message:

Merge qmuparallel and qmuserial

Location:

issm/trunk/src/m/solutions/dakota

Files:

• process_qmu_options.m (copied) (copied from issm/trunk/src/m/classes/public/process_solve_options.m ) (8 diffs)
• qmu.m (copied) (copied from issm/trunk/src/m/classes/public/qmu.m ) (2 diffs)
• qmumarshall.m (added)
• qmuserial.m (modified) (1 diff)
• recover_qmu_options.m (copied) (copied from issm/trunk/src/m/classes/public/recover_solve_options.m ) (2 diffs)

issm/trunk/src/m/solutions/dakota/process_qmu_options.m

@@ -1 @@
-function outoptions=process_solve_options(options)
-%DEFAULT_SOLVE_OPTIONS - set up default options for solve phase
+function outoptions=process_qmu_options(options)
+%PROCESS_QMU_OPTIONS - set up default options for qmu phase
 %
 %   Usage:
-%      options=process_solve_options(options)
+%      options=process_qmu_options(options)
 %
-%   See also: SOLVE,RECOVER_SOLVE_OPTIONS
+%   See also: QMU,RECOVER_QMU_OPTIONS
 
 %analysis_type: check on this option, error out otherwise
@@ -16 +16 @@
 end
 if ~found,
-        error('recover_solve_options error message: no ''analysis_type'' was provided');
+        error('recover_qmu_options error message: no ''analysis_type'' was provided');
 end
 
-%package: is there one? check to ''cielo''
+%package: is there one? default to ''cielo''
 found=0;
 for i=1:size(options,1),
@@ -28 +28 @@
 end
 if ~found,
-        disp('recover_solve_options info message: no ''package'' was provided, defaulting to ''cielo''');
+        disp('recover_qmu_options info message: no ''package'' was provided, defaulting to ''cielo''');
         options(end+1,:)={'package' 'cielo'};
         package='cielo';
@@ -34 +34 @@
 
 if ~ischar(package), 
-        error(['process_solve_options error message: package ' package ' not supported yet']);
+        error(['process_qmu_options error message: package ' package ' not supported yet']);
 end
 
@@ -49 +49 @@
                 sub_analysis_type='none';
         else
-                disp('recover_solve_options info message: no ''sub_analysis_type'' was provided, defaulting to ''steady''');
+                disp('recover_qmu_options info message: no ''sub_analysis_type'' was provided, defaulting to ''steady''');
                 sub_analysis_type='steady';
         end
@@ -63 +63 @@
                 strcmpi(analysis_type,'mesh2grid') |  ...
                 strcmpi(analysis_type,'transient') ),
-        error(['process_solve_options error message: analysis_type ' analysis_type ' not supported yet!']);
+        error(['process_qmu_options error message: analysis_type ' analysis_type ' not supported yet!']);
 end
 if ~(strcmpi(sub_analysis_type,'none') |  ...
@@ -71 +71 @@
                 strcmpi(sub_analysis_type,'') |  ...
                 strcmpi(sub_analysis_type,'transient') ),
-        error(['process_solve_options error message: sub_analysis_type ' sub_analysis_type ' not supported yet!']);
+        error(['process_qmu_options error message: sub_analysis_type ' sub_analysis_type ' not supported yet!']);
 end
 if ~(strcmpi(package,'cielo') |  ...
                 strcmpi(package,'ice') |  ...
                 strcmpi(package,'macayeal') ),
-        error(['process_solve_options error message: package ' package ' not supported yet!']);
+        error(['process_qmu_options error message: package ' package ' not supported yet!']);
+end
+
+
+
+
+%  process qmu arguments
+
+%first, the defaults
+qmudir ='qmu';% qmudir =['qmu_' datestr(now,'yyyymmdd_HHMMSS')];
+qmufile='qmu';%  qmufile can not be changed unless cielo_ice_script.sh is also changed
+ivar   =1;
+iresp  =1;
+imethod=1;
+iparams=1;
+runmpi =false;
+
+for i=1:size(options,1),
+        switch options{i,1},
+        case 'qmudir'
+                qmudir=options{i,2};
+        case 'qmufile'
+                qmufile=options{i,2};
+        case 'ivar'
+                ivar=options{i,2};
+        case 'iresp'
+                iresp=options{i,2};
+        case 'imethod'
+                imethod=options{i,2};
+        case 'iparams'
+                iparams=options{i,2};
+        case 'overwrite'
+                outoptions.overwrite=options{i,2};
+        case 'outfiles'
+                outoptions.outfiles=options{i,2};
+        case 'rstfile'
+                outoptions.rstfile=options{i,2}; 
+        case 'rundakota'
+                outoptions.rundakota=options{i,2};
+        case 'runmpi'
+                runmpi=options{i,2};
+        otherwise
+                %nothing
+        end
 end
 
@@ -83 +126 @@
 outoptions.package=package;
 outoptions.sub_analysis_type=sub_analysis_type;
+outoptions.qmudir=qmudir;
+outoptions.qmufile=qmufile;
+outoptions.ivar=ivar;
+outoptions.iresp=iresp;
+outoptions.imethod=imethod;
+outoptions.iparams=iparams;
+outoptions.runmpi=runmpi;
+

issm/trunk/src/m/solutions/dakota/qmu.m

@@ -37 +37 @@
 
 %recover options
-options=recover_solve_options(md,varargin{:});
+options=recover_qmu_options(md,varargin{:});
 
 %add default options
-options=process_solve_options(options);
+options=process_qmu_options(options);
 
 %recover some fields
@@ -56 +56 @@
 displaystring(md.debug,'\n%s\n','launching solution sequence');
 
-%Ok, are we running serially or in parallel?
-if ~strcmpi(md.cluster,'none'),
-        %ok, we are running parallel. 
-        md=qmuparallel(md,varargin{:});
+
+%first create temporary directory in which we will work
+if exist(options.qmudir,'dir')
+    if ~isfield(options,'overwrite')
+        options.overwrite=input(['Overwrite existing ''' options.qmudir ''' directory? Y/N [N]: '], 's');
+    end
+    if strncmpi(options.overwrite,'y',1)
+        system(['rm -rf ' options.qmudir]);
+%    else
+%        error('Existing ''%s'' directory not overwritten.',qmudir);
+    end
+end
+mkdir(options.qmudir)
+cd(options.qmudir)
+
+%some data needs to be copied in qmudir when not running in library mode
+if ~md.dakotaplugin,
+        system('cp $ISSM_DIR/startup.m .');
+
+        %save our model in qmu so that it can be repeatedly used by Dakota.
+        save('Qmu.model','md')
+end
+
+%when running in library mode, the in file needs to be called md.name.qmu.in
+if md.dakotaplugin,
+        options.qmufile=[md.name ];
+end
+
+%create m and in files for dakota
+if (~isfield(md.qmu_params(options.iparams),'direct') || ...
+    ~md.qmu_params(options.iparams).direct) && ...
+   (~isfield(md.qmu_params(options.iparams),'analysis_driver') || ...
+    isempty(md.qmu_params(options.iparams).analysis_driver))
+    md.qmu_params(options.iparams).analysis_driver=[ISSM_DIR '/src/m/solutions/dakota/cielo_ice_script.sh'];
+end
+
+%create m and in files for dakota
+dakota_in_data(md.qmu_method(options.imethod),md.variables(options.ivar),md.responses(options.iresp),md.qmu_params(options.iparams),options.qmufile,package,md);
+
+
+%in library mode, we only need the dakota in file
+if md.dakotaplugin,
+        system(['rm -rf ' md.name '.m']);
+end
+
+%Dakota can be run in library mode in parallel, or using the 
+%standard Dakota (scripted or direct) interface. Those two 
+%modes of running are very different, and call for different 
+%solution sequences. We branch here. 
+
+if md.dakotaplugin,
+
+        %Check we are running in parallel.
+        if strcmpi(md.cluster,'none'),
+                error('qmu error message: cannot run in library mode serially! set dakotaplugin to 0');
+        end
+
+        %Get cluster.rc location
+        cluster_rc_location=which('cluster.rc');
+
+        %let solution sequences know that we are running in qmu mode
+        md.qmu_analysis=1;
+
+        %Figure out parameters for this particular cluster
+        [codepath,executionpath]=ClusterParameters(md.cluster,cluster_rc_location);
+
+        %Marshall model data into a binary file.
+        marshall(md);
+
+        %add qmu fields to binary file
+        qmumarshall(md,md.variables(options.ivar),md.responses(options.iresp));
+
+        %Now, we need to build the queuing script, used by the cluster to launch the job.
+        BuildQueueingScript(md,executionpath,codepath);
+
+        %Now, launch the queueing script
+        LaunchQueueJob(md,executionpath);
+
+        %Do we return, or just wait for results?
+        if md.waitonlock,
+                %we wait for the done file
+                waitonlock([executionpath '/' md.name '.lock']);
+                %load results
+                md=loadresultsfromcluster(md);
+        else
+                return;
+        end
+        
 else
-        %we are running serially.
-        md=qmuserial(md,varargin{:});
-end
+%  check for existence of results.out files to use
+        if exist('results.out.1','file') || exist('results.out.zip','file')
+                if ~isfield(options,'outfiles')
+                        options.outfiles=input(['Use existing ''results.out'' files? Y/N [N]: '], 's');
+                end
+                if ~strncmpi(options.outfiles,'y',1)
+                        system('rm -f results.out.[1-9]*');
+                else
+                        if exist('results.out.zip','file') && ~exist('results.out.1','file')
+                                display('Inflating ''results.out.zip'' file.');
+                                system('unzip -q results.out.zip');
+                        end
+                end
+        end
+
+        %  check for existence of dakota.rst file to use
+        rstflag='';
+        if (~isfield(options,'outfiles') || ~strncmpi(options.outfiles,'y',1)) && ...
+                exist('dakota.rst','file')
+                if ~isfield(options,'rstfile')
+                        options.rstfiles=input(['Use existing ''dakota.rst'' file? Y/N [N]: '], 's');
+                end
+                if strncmpi(options.rstfiles,'y',1)
+                        system('rm -f results.out.[1-9]*');
+                        system('dakota_restart_util print dakota.rst | grep completed');
+                        rstflag=' -read_restart dakota.rst';
+                end
+        end
+
+        %call dakota
+        if ~isfield(options,'rundakota')
+                options.rundakota=input(['Run Dakota analysis ''' qmufile '''? Y/N [N]: '], 's');
+        end
+        if ~strncmpi(options.rundakota,'y',1)
+                cd ..
+                return
+        end
+
+        if ~options.runmpi
+                system(['dakota -i ' qmufile '.in -o ' qmufile '.out -e ' qmufile '.err' rstflag]);
+        else
+        %  use 'mpd --ncpus=8 &' to initialize mpi and 'mpdringtest' to verify.
+        %  exporting MPIRUN_NPROCS sets mpi in dakota.
+        %    system('mpd --ncpus=8 &');
+        %    system('mpdringtest');
+                system(['export MPIRUN_NPROCS=8;mpirun -np 4 dakota -i ' qmufile '.in -o ' qmufile '.out -e ' qmufile '.err' rstflag]);
+        end
+
+end
+
+
+
+%Now load the results from dakota output files.
+qmuoutput(md,options.qmufile,options.qmudir);
+
+%Get out of qmu directory
+cd ..
+

issm/trunk/src/m/solutions/dakota/qmuserial.m

@@ -14 +14 @@
 iparams=1;
 runmpi =false;
+
 
 %  process any extra input arguments

issm/trunk/src/m/solutions/dakota/recover_qmu_options.m

@@ -1 @@
-function options=recover_solve_options(md,varargin)
-%RECOVER_SOLVE_OPTIONS - recover solution options
+function options=recover_qmu_options(md,varargin)
+%RECOVER_SOLVE_OPTIONS - recover solution options for qmu runs.
 %
 %   Usage:
-%      options=recover_solve_options(md,varargin);
+%      options=recover_qmu_options(md,varargin);
 %
 %   See also: SOLVE
@@ -12 +12 @@
 %make sure length(varargin) is even, ie options come in pairs.
 if mod(length(varargin),2),
-        error('recover_solve_options error message: an even number of options is necessary');
+        error('recover_qmu_options error message: an even number of options is necessary');
 end