Changeset 11871

Timestamp:

04/03/12 10:11:50 (13 years ago)

Author:

Mathieu Morlighem

Message:

solver is now an object with dynamic properties, and each property is a struct with all the PETSc options

Location:

issm/trunk-jpl/src/m

Files:

• classes/solver.m (modified) (4 diffs)
• model/solvers/asmoptions.m (modified) (2 diffs)
• model/solvers/iluasmoptions.m (modified) (2 diffs)
• model/solvers/jacobiasmoptions.m (modified) (2 diffs)
• model/solvers/jacobicgoptions.m (modified) (2 diffs)
• model/solvers/matlaboptions.m (modified) (2 diffs)
• model/solvers/mumpsoptions.m (modified) (2 diffs)
• model/solvers/soroptions.m (modified) (2 diffs)
• model/solvers/stokesoptions.m (modified) (3 diffs)

issm/trunk-jpl/src/m/classes/solver.m ¶

@@ -6 +6 @@
 classdef solver < dynamicprops
     properties (SetAccess=public) 
-                 NoneAnalysis
+                 NoneAnalysis = struct();
                  %The other properties are dynamic
          end
@@ -18 +18 @@
                                  end
                          end % }}}
-                 function obj = setdefaultparameters(obj) % {{{
-
-                         %MUMPS is the default solver
-                         if ismumps,
-                                 obj.NoneAnalysis=mumpsoptions;
-                         else
-                                 obj.NoneAnalysis=iluasmoptions;
-                         end
-
-                 end % }}}
                  function obj = addoptions(obj,analysis,solveroptions) % {{{1
 
@@ -42 +32 @@
                  end
                  %}}}
+                 function obj = setdefaultparameters(obj) % {{{
+
+                         %MUMPS is the default solver
+                         if ismumps,
+                                 obj.NoneAnalysis=mumpsoptions;
+                         else
+                                 obj.NoneAnalysis=iluasmoptions;
+                         end
+
+                 end % }}}
+                 function disp(obj) % {{{
+                         analyses=properties(obj);
+                         disp(sprintf('List of solver options per analysis:\n'));
+                         for i=1:numel(analyses),
+                                 analysis=analyses{i};
+                                 disp([analysis ':']);
+                                 disp(obj.(analysis));
+                         end
+                 end % }}}
                  function checkconsistency(obj,md,solution,analyses) % {{{
                          %Nothing checked
@@ -71 +80 @@
 
                                  %now, write options
-                                 for j=1:size(options,2),
-                                         option=options{j};
-                                         if isempty(option),
-                                                 %do nothing
-                                         elseif length(option)==1,
+                                 optionslist=fieldnames(options);
+                                 for j=1:numel(optionslist),
+                                         optionname=optionslist{j};
+                                         optionvalue=options.(optionname);
+
+                                         if isempty(optionvalue),
                                                  %this option has only one argument
-                                                 fprintf(fid,'-%s\n',option{1});
-                                         elseif length(option)==2,
+                                                 fprintf(fid,'-%s\n',optionname);
+                                         else
                                                  %option with value. value can be string or scalar
-                                                 if isscalar(option{2}),
-                                                         fprintf(fid,'-%s %g\n',option{1},option{2});
-                                                 elseif ischar(option{2}),
-                                                         fprintf(fid,'-%s %s\n',option{1},option{2});
+                                                 if isscalar(optionvalue),
+                                                         fprintf(fid,'-%s %g\n',optionname,optionvalue);
+                                                 elseif ischar(optionvalue),
+                                                         fprintf(fid,'-%s %s\n',optionname,optionvalue);
                                                  else
-                                                         error(['PetscFile error: option #' num2str(j) ' is not well formatted']);
+                                                         error(['PetscFile error: option ' optionname ' is not well formatted']);
                                                  end
-                                         else 
-                                                 error(['PetscFile error: option #' num2str(j) ' is not well formatted']);
                                          end
                                  end

issm/trunk-jpl/src/m/model/solvers/asmoptions.m ¶

@@ -1 @@
-function options=asmoptions(varargin)
+function asm=asmoptions(varargin)
 %ASMOPTIONS - return Additive Shwartz Method petsc options
 %
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+asm=struct();
 
 %default asm options
-options={{'mat_type','aij'},{'ksp_type','gmres'},{'pc_type','asm'},{'sub_pc_type','lu'},{'pc_asm_overlap',3},{'ksp_max_it',100},{'ksp_rtol',1e-30'}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+asm.mat_type=getfieldvalue(options,'mat_type','aij');
+asm.ksp_type=getfieldvalue(options,'ksp_type','gmres');
+asm.pc_type=getfieldvalue(options,'pc_type','asm');
+asm.sub_pc_type=getfieldvalue(options,'sub_pc_type','lu');
+asm.pc_asm_overlap=getfieldvalue(options,'pc_asm_overlap',3);
+asm.ksp_max_it=getfieldvalue(options,'ksp_max_it',100);
+asm.ksp_rtol=getfieldvalue(options,'ksp_rtol',1e-30);

issm/trunk-jpl/src/m/model/solvers/iluasmoptions.m ¶

@@ -1 @@
-function options=iluasmoptions(varargin)
-%ASMOPTIONS - return Additive Shwartz Method with ILU preconditioner petsc options
+function iluasm=iluasmoptions(varargin)
+%ILUASMOPTIONS - 
 %
 %   Usage:
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+iluasm=struct();
 
 %default iluasm options
-options={{'mat_type','aij'},{'ksp_type','gmres'},{'pc_type','asm'},{'sub_pc_type','ilu'},{'pc_asm_overlap',5},{'ksp_max_it',100},{'ksp_rtol',1e-15'}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+iluasm.mat_type=getfieldvalue(options,'mat_type''','aij');
+iluasm.ksp_type=getfieldvalue(options,'ksp_type''','gmres');
+iluasm.pc_type=getfieldvalue(options,'pc_type''','asm');
+iluasm.sub_pc_type=getfieldvalue(options,'sub_pc_type''','ilu');
+iluasm.pc_asm_overlap=getfieldvalue(options,'pc_asm_overlap',5);
+iluasm.ksp_max_it=getfieldvalue(options,'ksp_max_it',100);
+iluasm.ksp_rtol=getfieldvalue(options,'ksp_rtol',1e-15);

issm/trunk-jpl/src/m/model/solvers/jacobiasmoptions.m ¶

@@ -1 @@
-function options=jacobiasmoptions(varargin)
+function jacobiasm=jacobiasmoptions(varargin)
 %ASMOPTIONS - return Additive Shwartz Method with Jacobi preconditioner petsc options
 %
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+jacobiasm=struct();
 
 %default jacobiasm options
-options={{'mat_type','aij'},{'ksp_type','gmres'},{'pc_type','asm'},{'sub_pc_type','jacobi'},{'pc_asm_overlap',3},{'ksp_max_it',100},{'ksp_rtol',1e-15'}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+jacobiasm.mat_type=getfieldvalue(options,'mat_type','aij');
+jacobiasm.ksp_type=getfieldvalue(options,'ksp_type','gmres');
+jacobiasm.pc_type=getfieldvalue(options,'pc_type','asm');
+jacobiasm.sub_pc_type=getfieldvalue(options,'sub_pc_type','jacobi');
+jacobiasm.pc_asm_overlap=getfieldvalue(options,'pc_asm_overlap',3);
+jacobiasm.ksp_max_it=getfieldvalue(options,'ksp_max_it',100);
+jacobiasm.ksp_rtol=getfieldvalue(options,'ksp_rtol',1e-15);

issm/trunk-jpl/src/m/model/solvers/jacobicgoptions.m ¶

@@ -1 @@
-function options=jacobiasmoptions(varargin)
+function jacobicg=jacobiacgoptions(varargin)
 %ASMOPTIONS - return Additive Shwartz Method with Jacobi preconditioner petsc options
 %
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+jacobicg=struct();
 
 %default jacobiasm options
-options={{'mat_type','aij'},{'ksp_type','cg'},{'ksp_max_it',100},{'ksp_rtol',1e-15'}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+jacobicg.mat_type=getfieldvalue(options,'mat_type','aij');
+jacobicg.ksp_type=getfieldvalue(options,'ksp_type','cg');
+jacobicg.ksp_max_it=getfieldvalue(options,'ksp_max_it',100);
+jacobicg.ksp_rtol=getfieldvalue(options,'ksp_rtol',1e-15);

issm/trunk-jpl/src/m/model/solvers/matlaboptions.m ¶

@@ -1 @@
-function options=matlaboptions(varargin)
+function maltab=matlaboptions(varargin)
 %MATLABOPTIONS - return Matlab petsc options
 %
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+maltab=struct();
 
 %default matlab options
-options={{'ksp_type','matlab'}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+maltab.ksp_type='matlab';

issm/trunk-jpl/src/m/model/solvers/mumpsoptions.m ¶

@@ -1 @@
-function options=mumpsoptions(varargin)
+function mumps=mumpsoptions(varargin)
 %MUMPSOPTIONS - return MUMPS direct solver  petsc options
 %
@@ -6 +6 @@
 
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+mumps=struct();
 
 %default mumps options
 PETSC_VERSION=petscversion();
 if PETSC_VERSION==2,
-        options={{'mat_type','aijmumps'},{'ksp_type','preonly'},{'pc_type','lu'},{'mat_mumps_icntl_14',120},{'pc_factor_shift_positive_definite','true'}};
+        mumps.mat_type=getfieldvalue(options,'mat_type','aijmumps');
+        mumps.ksp_type=getfieldvalue(options,'ksp_type','preonly');
+        mumps.pc_type=getfieldvalue(options,'pc_type','lu');
+        mumps.mat_mumps_icntl_14=getfieldvalue(options,'mat_mumps_icntl_14',120);
+        mumps.pc_factor_shift_positive_definite=getfieldvalue(options,'pc_factor_shift_positive_definite','true');
 end
 if PETSC_VERSION==3,
-        options={{'mat_type','mpiaij'},{'ksp_type','preonly'},{'pc_type','lu'},{'pc_factor_mat_solver_package','mumps'},{'mat_mumps_icntl_14',120},{'pc_factor_shift_positive_definite','true'}};
-
+        mumps.mat_type=getfieldvalue(options,'mat_type','mpiaij');
+        mumps.ksp_type=getfieldvalue(options,'ksp_type','preonly');
+        mumps.pc_type=getfieldvalue(options,'pc_type','lu');
+        mumps.pc_factor_mat_solver_package=getfieldvalue(options,'pc_factor_mat_solver_package','mumps');
+        mumps.mat_mumps_icntl_14=getfieldvalue(options,'mat_mumps_icntl_14',120);
+        mumps.pc_factor_shift_positive_definite=getfieldvalue(options,'pc_factor_shift_positive_definite','true');
 end
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end

issm/trunk-jpl/src/m/model/solvers/soroptions.m ¶

@@ -1 @@
-function options=soroptions(varargin)
+function sor=soroptions(varargin)
 %SOROPTIONS - return Relaxation Solver petsc options
 %
@@ -6 +6 @@
                          
 %retrieve options provided in varargin
-arguments=pairoptions(varargin{:});
+options=pairoptions(varargin{:});
+sor=struct();
 
 %default sor options
-options={{'mat_type','aij'},{'ksp_type','cg'},{'pc_type','sor'},{'pc_sor_omega',1.1},{'pc_sor_its',2}};
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end
+sor.mat_type=getfieldvalue(options,'mat_type','aij');
+sor.ksp_type=getfieldvalue(options,'ksp_type','cg');
+sor.pc_type=getfieldvalue(options,'pc_type','sor');
+sor.pc_sor_omega=getfieldvalue(options,'pc_sor_omega',1.1);
+sor.pc_sor_its=getfieldvalue(options,'pc_sor_its',2);

issm/trunk-jpl/src/m/model/solvers/stokesoptions.m ¶

@@ -1 @@
-function options=stokesoptions(varargin)
+function stokes=stokesoptions(varargin)
 %STOKESOPTIONS - return STOKES multi-physics solver petsc options
 %
@@ -7 +7 @@
 %retrieve options provided in varargin
 arguments=pairoptions(varargin{:});
+stokes=struct();
 
 %default stokes options
@@ -14 +15 @@
 end
 if PETSC_VERSION==3,
-        options={{'mat_type','mpiaij'},{'ksp_max_it',1000},{'ksp_type','gmres'},{'pc_type','fieldsplit'},{'pc_field_split_type','schur'},...
-        {'fieldsplit_0_pc_type','hypre'},{'fieldsplit_0_ksp_type','gmres'},{'fieldsplit_0_pc_hypre_type','boomerang'},...
-        {'fieldsplit_1_pc_type','jacobi'},{'fieldsplit_1_ksp_type','preonly'},{'issm_option_solver','stokes'}};
+        stokes.mat_type=getfieldvalue(options,'mat_type','mpiaij');
+        stokes.ksp_max_it=getfieldvalue(options,'ksp_max_it',1000);
+        stokes.ksp_type=getfieldvalue(options,'ksp_type','gmres');
+        stokes.pc_type=getfieldvalue(options,'pc_type','fieldsplit');
+        stokes.pc_field_split_type=getfieldvalue(options,'pc_field_split_type','schur');
+        stokes.fieldsplit_0_pc_type=getfieldvalue(options,'fieldsplit_0_pc_type','hypre');
+        stokes.fieldsplit_0_ksp_type=getfieldvalue(options,'fieldsplit_0_ksp_type','gmres');
+        stokes.fieldsplit_0_pc_hypre_type=getfieldvalue(options,'fieldsplit_0_pc_hypre_type','boomerang');
+        stokes.fieldsplit_1_pc_type=getfieldvalue(options,'fieldsplit_1_pc_type','jacobi');
+        stokes.fieldsplit_1_ksp_type=getfieldvalue(options,'fieldsplit_1_ksp_type','preonly');
+        stokes.issm_option_solver=getfieldvalue(options,'issm_option_solver','stokes');
 end
-
-%now, go through our arguments, and write over default options.
-for i=1:size(arguments.list,1),
-        arg1=arguments.list{i,1};
-        arg2=arguments.list{i,2};
-        found=0;
-        for j=1:size(options,2),
-                joption=options{j};
-                if strcmpi(joption{1},arg1),
-                        joption{2}=arg2;
-                        options{j}=joption;
-                        found=1;
-                        break;
-                end
-        end
-        if ~found,
-                %this option did not exist, add it: 
-                options{end+1}={arg1,arg2};
-        end
-end