Changeset 10969


Ignore:
Timestamp:
11/29/11 16:03:56 (13 years ago)
Author:
Mathieu Morlighem
Message:

Improvement: marshall is now a method of all model fields, removed unnecessary model fields (numcontrols... etc)

Location:
issm/trunk-jpl/src/m
Files:
1 added
1 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/classes/autodiff.m

    r9902 r10969  
    66classdef autodiff
    77        properties (SetAccess=public)
    8                 isautodiff = modelfield('default',false,'marshall',true,'format','Boolean');
    9                 forward    = modelfield('default',true,'marshall',true,'format','Boolean');
    10                 reverse    = modelfield('default',false,'marshall',true,'format','Boolean');
     8                isautodiff = false;
     9                forward    = true;
     10                reverse    = false;
    1111        end
    1212        methods
    … …  
    2828                function obj = setdefaultparameters(obj) % {{{
    2929
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3630                end % }}}
    3731                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    4640
    4741                end % }}}
     42                function marshall(obj,fid) % {{{
     43                        WriteData(fid,'object',obj,'fieldname','isautodiff','format','Boolean');
     44                        WriteData(fid,'object',obj,'fieldname','forward','format','Boolean');
     45                        WriteData(fid,'object',obj,'fieldname','reverse','format','Boolean');
     46                end % }}}
    4847        end
    4948end

  • issm/trunk-jpl/src/m/classes/balancethickness.m

    r10276 r10969  
    66classdef balancethickness
    77        properties (SetAccess=public)
    8                 spcthickness      = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 thickening_rate   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    10                 stabilization     = modelfield('default',0,'marshall',true,'format','Integer');
     8                spcthickness      = NaN;
     9                thickening_rate   = NaN;
     10                stabilization     = 0;
    1111        end
    1212        methods
    … …  
    2727                end % }}}
    2828                function obj = setdefaultparameters(obj) % {{{
    29 
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3629
    3730                        %Type of stabilization used
    … …  
    5548
    5649                end % }}}
     50                function marshall(obj,fid) % {{{
     51                        WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1);
     52                        WriteData(fid,'object',obj,'fieldname','thickening_rate','format','DoubleMat','mattype',1);
     53                        WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
     54                end % }}}
    5755        end
    5856end

  • issm/trunk-jpl/src/m/classes/basalforcings.m

    r9860 r10969  
    66classdef basalforcings
    77        properties (SetAccess=public)
    8                 melting_rate             = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 melting_rate_correction  = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    10                 geothermalflux           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
     8                melting_rate             = NaN;
     9                melting_rate_correction  = NaN;
     10                geothermalflux           = NaN;
    1111        end
    1212        methods
    … …  
    2828                function obj = setdefaultparameters(obj) % {{{
    2929
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3630                end % }}}
    3731                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    5650
    5751                end % }}}
     52                function marshall(obj,fid) % {{{
     53                        WriteData(fid,'object',obj,'fieldname','melting_rate','format','DoubleMat','mattype',1);
     54                        WriteData(fid,'object',obj,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1);
     55                        WriteData(fid,'object',obj,'fieldname','geothermalflux','format','DoubleMat','mattype',1);
     56                end % }}}
    5857        end
    5958end

  • issm/trunk-jpl/src/m/classes/constants.m

    r9860 r10969  
    66classdef constants
    77        properties (SetAccess=public)
    8                 g                    = modelfield('default',0,'marshall',true,'format','Double');
    9                 yts                  = modelfield('default',0,'marshall',true,'format','Double');
    10                 referencetemperature = modelfield('default',0,'marshall',true,'format','Double');
     8                g                    = 0;
     9                yts                  = 0;
     10                referencetemperature = 0;
    1111        end
    1212        methods
    … …  
    2727                end % }}}
    2828                function obj = setdefaultparameters(obj) % {{{
    29 
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3629
    3730                        %acceleration due to gravity (m/s^2)
    … …  
    6053
    6154                end % }}}
     55                function marshall(obj,fid) % {{{
     56                        WriteData(fid,'object',obj,'fieldname','g','format','Double');
     57                        WriteData(fid,'object',obj,'fieldname','yts','format','Double');
     58                        WriteData(fid,'object',obj,'fieldname','referencetemperature','format','Double');
     59                end % }}}
    6260        end
    6361end

  • issm/trunk-jpl/src/m/classes/diagnostic.m

    r10555 r10969  
    66classdef diagnostic
    77        properties (SetAccess=public)
    8                 spcvx                    = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 spcvy                    = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    10                 spcvz                    = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    11                 restol                   = modelfield('default',0,'marshall',true,'format','Double');
    12                 reltol                   = modelfield('default',0,'marshall',true,'format','Double');
    13                 abstol                   = modelfield('default',0,'marshall',true,'format','Double');
    14                 stokesreconditioning     = modelfield('default',0,'marshall',true,'format','Double');
    15                 viscosity_overshoot      = modelfield('default',0,'marshall',true,'format','Double');
    16                 icefront                 = modelfield('default',NaN,'marshall',true,'preprocess','marshallicefront','format','DoubleMat','mattype',3);
    17                 maxiter                  = modelfield('default',0,'marshall',true,'format','Integer');
    18                 shelf_dampening          = modelfield('default',0,'marshall',true,'format','Integer');
    19                 vertex_pairing           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    20                 penalty_factor           = modelfield('default',0,'marshall',true,'format','Double');
    21                 rift_penalty_lock        = modelfield('default',0,'marshall',true,'format','Integer');
    22                 rift_penalty_threshold   = modelfield('default',0,'marshall',true,'format','Integer');
    23                 referential              = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    24                 requested_outputs        = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
     8                spcvx                    = NaN;
     9                spcvy                    = NaN;
     10                spcvz                    = NaN;
     11                restol                   = 0;
     12                reltol                   = 0;
     13                abstol                   = 0;
     14                stokesreconditioning     = 0;
     15                viscosity_overshoot      = 0;
     16                icefront                 = NaN;
     17                maxiter                  = 0;
     18                shelf_dampening          = 0;
     19                vertex_pairing           = NaN;
     20                penalty_factor           = NaN;
     21                rift_penalty_lock        = NaN;
     22                rift_penalty_threshold   = 0;
     23                referential              = NaN;
     24                requested_outputs        = NaN;
    2525        end
    2626        methods
    … …  
    4141                end % }}}
    4242                function obj = setdefaultparameters(obj) % {{{
    43 
    44                         %first, use the defaults provided by the properties definition above.
    45                         fieldnames=fields(obj);
    46                         for i=1:length(fieldnames),
    47                                 fieldname=fieldnames{i};
    48                                 obj.(fieldname)=obj.(fieldname).default;
    49                         end
    5043
    5144                         %maximum of non-linear iterations.
    … …  
    157150
    158151                end % }}}
     152                function marshall(obj,fid) % {{{
     153                        WriteData(fid,'object',obj,'fieldname','spcvx','format','DoubleMat','mattype',1);
     154                        WriteData(fid,'object',obj,'fieldname','spcvy','format','DoubleMat','mattype',1);
     155                        WriteData(fid,'object',obj,'fieldname','spcvz','format','DoubleMat','mattype',1);
     156                        WriteData(fid,'object',obj,'fieldname','restol','format','Double');
     157                        WriteData(fid,'object',obj,'fieldname','reltol','format','Double');
     158                        WriteData(fid,'object',obj,'fieldname','abstol','format','Double');
     159                        WriteData(fid,'object',obj,'fieldname','stokesreconditioning','format','Double');
     160                        WriteData(fid,'object',obj,'fieldname','viscosity_overshoot','format','Double');
     161                        WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
     162                        WriteData(fid,'object',obj,'fieldname','shelf_dampening','format','Integer');
     163                        WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
     164                        WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
     165                        WriteData(fid,'object',obj,'fieldname','rift_penalty_lock','format','Integer');
     166                        WriteData(fid,'object',obj,'fieldname','rift_penalty_threshold','format','Integer');
     167                        WriteData(fid,'object',obj,'fieldname','referential','format','DoubleMat','mattype',1);
     168                        WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3);
     169
     170                        %marshall ice front
     171                        data=obj.icefront;
     172                        pos=find(data(:,end)==0); data(pos,end)=AirEnum;
     173                        pos=find(data(:,end)==1); data(pos,end)=WaterEnum;
     174                        pos=find(data(:,end)==2); data(pos,end)=IceEnum;
     175                        WriteData(fid,'data',data,'enum',DiagnosticIcefrontEnum,'format','DoubleMat','mattype',3);
     176                end % }}}
    159177        end
    160178end

  • issm/trunk-jpl/src/m/classes/flowequation.m

    r10244 r10969  
    66classdef flowequation
    77        properties (SetAccess=public)
    8                 ismacayealpattyn     = modelfield('default',0,'marshall',true,'format','Boolean');
    9                 ishutter             = modelfield('default',0,'marshall',true,'format','Boolean');
    10                 isstokes             = modelfield('default',0,'marshall',true,'format','Boolean');
    11                 vertex_equation      = modelfield('default',NaN,'marshall',true,'preprocess','marshallapproximations','format','DoubleMat','mattype',1);
    12                 element_equation     = modelfield('default',NaN,'marshall',true,'preprocess','marshallapproximations','format','DoubleMat','mattype',2);
    13                 bordermacayeal       = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    14                 borderpattyn         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    15                 borderstokes         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
     8                ismacayealpattyn     = 0;
     9                ishutter             = 0;
     10                isstokes             = 0;
     11                vertex_equation      = NaN;
     12                element_equation     = NaN;
     13                bordermacayeal       = NaN;
     14                borderpattyn         = NaN;
     15                borderstokes         = NaN;
    1616        end
    1717        methods
    … …  
    3232                end % }}}
    3333                function obj = setdefaultparameters(obj) % {{{
    34 
    35                         %first, use the defaults provided by the properties definition above.
    36                         fieldnames=fields(obj);
    37                         for i=1:length(fieldnames),
    38                                 fieldname=fieldnames{i};
    39                                 obj.(fieldname)=obj.(fieldname).default;
    40                         end
    4134
    4235                end % }}}
    … …  
    8275
    8376                end % }}}
     77                function marshall(obj,fid) % {{{
     78                        WriteData(fid,'object',obj,'fieldname','ismacayealpattyn','format','Boolean');
     79                        WriteData(fid,'object',obj,'fieldname','ishutter','format','Boolean');
     80                        WriteData(fid,'object',obj,'fieldname','isstokes','format','Boolean');
     81                        WriteData(fid,'object',obj,'fieldname','bordermacayeal','format','DoubleMat','mattype',1);
     82                        WriteData(fid,'object',obj,'fieldname','borderpattyn','format','DoubleMat','mattype',1);
     83                        WriteData(fid,'object',obj,'fieldname','borderstokes','format','DoubleMat','mattype',1);
     84                        %convert approximations to enums
     85                        data=obj.vertex_equation;
     86                        pos=find(data==0); data(pos,end)=NoneApproximationEnum;
     87                        pos=find(data==1); data(pos,end)=HutterApproximationEnum;
     88                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum;
     89                        pos=find(data==3); data(pos,end)=PattynApproximationEnum;
     90                        pos=find(data==4); data(pos,end)=StokesApproximationEnum;
     91                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum;
     92                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum;
     93                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum;
     94                        WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum,'format','DoubleMat','mattype',1);
     95                        data=obj.element_equation;
     96                        pos=find(data==0); data(pos,end)=NoneApproximationEnum;
     97                        pos=find(data==1); data(pos,end)=HutterApproximationEnum;
     98                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum;
     99                        pos=find(data==3); data(pos,end)=PattynApproximationEnum;
     100                        pos=find(data==4); data(pos,end)=StokesApproximationEnum;
     101                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum;
     102                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum;
     103                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum;
     104                        WriteData(fid,'data',data,'enum',FlowequationElementEquationEnum,'format','DoubleMat','mattype',2);
     105                end % }}}
    84106        end
    85107end

  • issm/trunk-jpl/src/m/classes/friction.m

    r9860 r10969  
    66classdef friction
    77        properties (SetAccess=public)
    8                 coefficient = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 p           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    10                 q           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
     8                coefficient = NaN;
     9                p           = NaN;
     10                q           = NaN;
    1111        end
    1212        methods
    … …  
    2828                function obj = setdefaultparameters(obj) % {{{
    2929
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    36 
    3730                end % }}}
    3831                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    5144                        fielddisplay(obj,'q','q exponent');
    5245                end % }}}
     46                function marshall(obj,fid) % {{{
     47                        WriteData(fid,'object',obj,'fieldname','coefficient','format','DoubleMat','mattype',1);
     48                        WriteData(fid,'object',obj,'fieldname','p','format','DoubleMat','mattype',2);
     49                        WriteData(fid,'object',obj,'fieldname','q','format','DoubleMat','mattype',2);
     50                end % }}}
    5351        end
    5452end

  • issm/trunk-jpl/src/m/classes/geometry.m

    r9860 r10969  
    66classdef geometry
    77        properties (SetAccess=public)
    8                 surface           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',SurfaceEnum);
    9                 thickness         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',ThicknessEnum);
    10                 bed               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',BedEnum);
    11                 bathymetry        = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',BathymetryEnum);
    12                 hydrostatic_ratio = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
     8                surface           = NaN;
     9                thickness         = NaN;
     10                bed               = NaN;
     11                bathymetry        = NaN;
     12                hydrostatic_ratio = NaN;
    1313        end
    1414        methods
    … …  
    2929                end % }}}
    3030                function obj = setdefaultparameters(obj) % {{{
    31 
    32                         %first, use the defaults provided by the properties definition above.
    33                         fieldnames=fields(obj);
    34                         for i=1:length(fieldnames),
    35                                 fieldname=fieldnames{i};
    36                                 obj.(fieldname)=obj.(fieldname).default;
    37                         end
    3831
    3932                end % }}}
    … …  
    5750
    5851                end % }}}
     52                function marshall(obj,fid) % {{{
     53                        WriteData(fid,'data',obj.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum);
     54                        WriteData(fid,'data',obj.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum);
     55                        WriteData(fid,'data',obj.bed,'format','DoubleMat','mattype',1,'enum',BedEnum);
     56                        WriteData(fid,'data',obj.bathymetry,'format','DoubleMat','mattype',1,'enum',BathymetryEnum);
     57                        WriteData(fid,'object',obj,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1);
     58                end % }}}
    5959        end
    6060end

  • issm/trunk-jpl/src/m/classes/groundingline.m

    r10446 r10969  
    66classdef groundingline
    77        properties (SetAccess=public)
    8                 migration    = modelfield('default','','marshall',true,'preprocess','StringToEnum','format','Integer');
    9                 melting_rate = modelfield('default',NaN,'marshall',true,'format','Double');
     8                migration    = '';
     9                melting_rate = NaN;
    1010        end
    1111        methods
    … …  
    2626                end % }}}
    2727                function obj = setdefaultparameters(obj) % {{{
    28 
    29                         %first, use the defaults provided by the properties definition above.
    30                         fieldnames=fields(obj);
    31                         for i=1:length(fieldnames),
    32                                 fieldname=fieldnames{i};
    33                                 obj.(fieldname)=obj.(fieldname).default;
    34                         end
    3528
    3629                        %Type of migration
    … …  
    6861
    6962                end % }}}
     63                function marshall(obj,fid) % {{{
     64                        WriteData(fid,'data',StringToEnum(obj.migration),'enum',GroundinglineMigrationEnum,'format','Integer');
     65                        WriteData(fid,'object',obj,'fieldname','melting_rate','format','Double');
     66                end % }}}
    7067        end
    7168end

  • issm/trunk-jpl/src/m/classes/hydrology.m

    r10565 r10969  
    66classdef hydrology
    77        properties (SetAccess=public)
    8                 spcwatercolumn = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 n              = modelfield('default',0,'marshall',true,'format','Double');
    10                 CR             = modelfield('default',0,'marshall',true,'format','Double');
    11                 p              = modelfield('default',0,'marshall',true,'format','Double');
    12                 q              = modelfield('default',0,'marshall',true,'format','Double');
    13                 kn             = modelfield('default',0,'marshall',true,'format','Double');
    14                 stabilization  = modelfield('default',0,'marshall',true,'format','Double');
     8                spcwatercolumn = NaN;
     9                n              = 0;
     10                CR             = 0;
     11                p              = 0;
     12                q              = 0;
     13                kn             = 0;
     14                stabilization  = 0;
    1515        end
    1616        methods
    … …  
    3131                end % }}}
    3232                function obj = setdefaultparameters(obj) % {{{
    33 
    34                         %first, use the defaults provided by the properties definition above.
    35                         fieldnames=fields(obj);
    36                         for i=1:length(fieldnames),
    37                                 fieldname=fieldnames{i};
    38                                 obj.(fieldname)=obj.(fieldname).default;
    39                         end
    4033
    4134                        %Parameters from Johnson's 2002 thesis, section 3.5.4                   
    … …  
    6962
    7063                end % }}}
     64                function marshall(obj,fid) % {{{
     65                        WriteData(fid,'object',obj,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1);
     66                        WriteData(fid,'object',obj,'fieldname','n','format','Double');
     67                        WriteData(fid,'object',obj,'fieldname','CR','format','Double');
     68                        WriteData(fid,'object',obj,'fieldname','p','format','Double');
     69                        WriteData(fid,'object',obj,'fieldname','q','format','Double');
     70                        WriteData(fid,'object',obj,'fieldname','kn','format','Double');
     71                        WriteData(fid,'object',obj,'fieldname','stabilization','format','Double');
     72                end % }}}
    7173        end
    7274end

  • issm/trunk-jpl/src/m/classes/initialization.m

    r9862 r10969  
    66classdef initialization
    77        properties (SetAccess=public)
    8                 vx            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',VxEnum);
    9                 vy            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',VyEnum);
    10                 vz            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',VzEnum);
    11                 vel           = modelfield('default',NaN,'marshall',false);
    12                 pressure      = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',PressureEnum);
    13                 temperature   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);
    14                 watercolumn   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum);
    15                 waterfraction = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum);
     8                vx            = NaN;
     9                vy            = NaN;
     10                vz            = NaN;
     11                vel           = NaN;
     12                pressure      = NaN;
     13                temperature   = NaN;
     14                watercolumn   = NaN;
     15                waterfraction = NaN;
    1616        end
    1717        methods
    … …  
    3232                end % }}}
    3333                function obj = setdefaultparameters(obj) % {{{
    34 
    35                         %first, use the defaults provided by the properties definition above.
    36                         fieldnames=fields(obj);
    37                         for i=1:length(fieldnames),
    38                                 fieldname=fieldnames{i};
    39                                 obj.(fieldname)=obj.(fieldname).default;
    40                         end
    4134
    4235                end % }}}
    … …  
    8376
    8477                end % }}}
     78                function marshall(obj,fid) % {{{
     79                        WriteData(fid,'data',obj.vx,'format','DoubleMat','mattype',1,'enum',VxEnum);
     80                        WriteData(fid,'data',obj.vy,'format','DoubleMat','mattype',1,'enum',VyEnum);
     81                        WriteData(fid,'data',obj.vz,'format','DoubleMat','mattype',1,'enum',VzEnum);
     82                        WriteData(fid,'data',obj.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum);
     83                        WriteData(fid,'data',obj.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);
     84                        WriteData(fid,'data',obj.watercolumn,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum);
     85                        WriteData(fid,'data',obj.waterfraction,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum);
     86                end % }}}
    8587        end
    8688end

  • issm/trunk-jpl/src/m/classes/inversion.m

    r10198 r10969  
    1818                step_threshold              = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    1919                gradient_only               = modelfield('default',0,'marshall',true,'format','Boolean');
    20                 num_control_parameters      = modelfield('default',0,'marshall',true,'format','Integer');
    21                 num_cost_functions          = modelfield('default',0,'marshall',true,'format','Integer');
    2220                vx_obs                      = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    2321                vy_obs                      = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    … …  
    126124                        fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
    127125                        fielddisplay(obj,'gradient_only','stop control method solution at gradient');
    128                         %fielddisplay(obj,'num_control_parameters','number of control_parameters');
    129                         %fielddisplay(obj,'num_cost_functions','number of cost_functions');
    130126                        fielddisplay(obj,'vx_obs','observed velocity x component [m/a]');
    131127                        fielddisplay(obj,'vy_obs','observed velocity y component [m/a]');
    … …  
    143139                        disp('   503: ThicknessAbsGradient');
    144140                end % }}}
     141                function marshall(obj,fid) % {{{
     142
     143                        WriteData(fid,'object',obj,'fieldname','iscontrol','format','Boolean');
     144                        if ~obj.iscontrol, return; end
     145                        WriteData(fid,'object',obj,'fieldname','nsteps','format','Integer');
     146                        WriteData(fid,'object',obj,'fieldname','maxiter_per_step','format','DoubleMat','mattype',3);
     147                        WriteData(fid,'object',obj,'fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
     148                        WriteData(fid,'object',obj,'fieldname','gradient_scaling','format','DoubleMat','mattype',3);
     149                        WriteData(fid,'object',obj,'fieldname','cost_function_threshold','format','Double');
     150                        WriteData(fid,'object',obj,'fieldname','min_parameters','format','DoubleMat','mattype',3);
     151                        WriteData(fid,'object',obj,'fieldname','max_parameters','format','DoubleMat','mattype',3);
     152                        WriteData(fid,'object',obj,'fieldname','step_threshold','format','DoubleMat','mattype',3);
     153                        WriteData(fid,'object',obj,'fieldname','gradient_only','format','Boolean');
     154                        WriteData(fid,'object',obj,'fieldname','vx_obs','format','DoubleMat','mattype',1);
     155                        WriteData(fid,'object',obj,'fieldname','vy_obs','format','DoubleMat','mattype',1);
     156                        WriteData(fid,'object',obj,'fieldname','vz_obs','format','DoubleMat','mattype',1);
     157                        WriteData(fid,'object',obj,'fieldname','thickness_obs','format','DoubleMat','mattype',1);
     158
     159                        %process control parameters
     160                        num_control_parameters=numel(obj.control_parameters);
     161                        data=zeros(1,num_control_parameters);
     162                        for i=1:num_control_parameters,
     163                                data(i)=StringToEnum(obj.control_parameters{i});
     164                        end
     165                        WriteData(fid,'data',data,'enum',InversionControlParametersEnum,'format','DoubleMat','mattype',3);
     166                        WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum,'format','Integer');
     167
     168                        %process cost functions
     169                        num_cost_functions=size(obj.cost_functions,2);
     170                        data=obj.cost_functions;
     171                        pos=find(data==101); data(pos)=SurfaceAbsVelMisfitEnum;
     172                        pos=find(data==102); data(pos)=SurfaceRelVelMisfitEnum;
     173                        pos=find(data==103); data(pos)=SurfaceLogVelMisfitEnum;
     174                        pos=find(data==104); data(pos)=SurfaceLogVxVyMisfitEnum;
     175                        pos=find(data==105); data(pos)=SurfaceAverageVelMisfitEnum;
     176                        pos=find(data==201); data(pos)=ThicknessAbsMisfitEnum;
     177                        pos=find(data==501); data(pos)=DragCoefficientAbsGradientEnum;
     178                        pos=find(data==502); data(pos)=RheologyBbarAbsGradientEnum;
     179                        pos=find(data==503); data(pos)=ThicknessAbsGradientEnum;
     180                        WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum,'format','DoubleMat','mattype',3);
     181                        WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum,'format','Integer');
     182                end % }}}
    145183        end
    146184end

  • issm/trunk-jpl/src/m/classes/mask.m

    r9862 r10969  
    66classdef mask
    77        properties (SetAccess=public)
    8                 elementonfloatingice = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    9                 elementongroundedice = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    10                 elementonwater       = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    11                 vertexonfloatingice  = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    12                 vertexongroundedice  = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    13                 vertexonwater        = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
     8                elementonfloatingice = NaN;
     9                elementongroundedice = NaN;
     10                elementonwater       = NaN;
     11                vertexonfloatingice  = NaN;
     12                vertexongroundedice  = NaN;
     13                vertexonwater        = NaN;
    1414        end
    1515        methods
    … …  
    3131                function obj = setdefaultparameters(obj) % {{{
    3232
    33                         %first, use the defaults provided by the properties definition above.
    34                         fieldnames=fields(obj);
    35                         for i=1:length(fieldnames),
    36                                 fieldname=fieldnames{i};
    37                                 obj.(fieldname)=obj.(fieldname).default;
    38                         end
    39 
    4033                end % }}}
    4134                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    4942                end % }}}
    5043                function disp(obj) % {{{
    51 
    5244                        fielddisplay(obj,'elementonfloatingice','element on floating ice flags list');
    5345                        fielddisplay(obj,'vertexonfloatingice','vertex on floating ice flags list');
    … …  
    5749                        fielddisplay(obj,'vertexonwater','vertex on water flags list');
    5850                end % }}}
     51                function marshall(obj,fid) % {{{
     52                        WriteData(fid,'object',obj,'fieldname','elementonfloatingice','format','BooleanMat','mattype',2);
     53                        WriteData(fid,'object',obj,'fieldname','elementongroundedice','format','BooleanMat','mattype',2);
     54                        WriteData(fid,'object',obj,'fieldname','elementonwater','format','BooleanMat','mattype',2);
     55                        WriteData(fid,'object',obj,'fieldname','vertexonfloatingice','format','DoubleMat','mattype',1);
     56                        WriteData(fid,'object',obj,'fieldname','vertexongroundedice','format','DoubleMat','mattype',1);
     57                        WriteData(fid,'object',obj,'fieldname','vertexonwater','format','DoubleMat','mattype',1);
     58                end % }}}
    5959        end
    6060end

  • issm/trunk-jpl/src/m/classes/materials.m

    r10565 r10969  
    66classdef materials
    77        properties (SetAccess=public)
    8                 rho_ice                    = modelfield('default',0,'marshall',true,'format','Double');
    9                 rho_water                  = modelfield('default',0,'marshall',true,'format','Double');
    10                 mu_water                   = modelfield('default',0,'marshall',true,'format','Double');
    11                 heatcapacity               = modelfield('default',0,'marshall',true,'format','Double');
    12                 latentheat                 = modelfield('default',0,'marshall',true,'format','Double');
    13                 thermalconductivity        = modelfield('default',0,'marshall',true,'format','Double');
    14                 meltingpoint               = modelfield('default',0,'marshall',true,'format','Double');
    15                 beta                       = modelfield('default',0,'marshall',true,'format','Double');
    16                 mixed_layer_capacity       = modelfield('default',0,'marshall',true,'format','Double');
    17                 thermal_exchange_velocity  = modelfield('default',0,'marshall',true,'format','Double');
    18                 rheology_B   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    19                 rheology_n   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    20                 rheology_law = modelfield('default','','marshall',true,'preprocess','StringToEnum','format','Integer');
     8                rho_ice                    = 0;
     9                rho_water                  = 0;
     10                mu_water                   = 0;
     11                heatcapacity               = 0;
     12                latentheat                 = 0;
     13                thermalconductivity        = 0;
     14                meltingpoint               = 0;
     15                beta                       = 0;
     16                mixed_layer_capacity       = 0;
     17                thermal_exchange_velocity  = 0;
     18                rheology_B   = NaN;
     19                rheology_n   = NaN;
     20                rheology_law = '';
    2121        end
    2222        methods
    … …  
    3737                end % }}}
    3838                function obj = setdefaultparameters(obj) % {{{
    39 
    40                         %first, use the defaults provided by the properties definition above.
    41                         fieldnames=fields(obj);
    42                         for i=1:length(fieldnames),
    43                                 fieldname=fieldnames{i};
    44                                 obj.(fieldname)=obj.(fieldname).default;
    45                         end
    4639
    4740                        %ice density (kg/m^3)
    … …  
    10497                        fielddisplay(obj,'rheology_law','law for the temperature dependance of the rheology: ''None'', ''Paterson'' or ''Arrhenius''');
    10598                end % }}}
     99                function marshall(obj,fid) % {{{
     100                        WriteData(fid,'object',obj,'fieldname','rho_ice','format','Double');
     101                        WriteData(fid,'object',obj,'fieldname','rho_water','format','Double');
     102                        WriteData(fid,'object',obj,'fieldname','mu_water','format','Double');
     103                        WriteData(fid,'object',obj,'fieldname','heatcapacity','format','Double');
     104                        WriteData(fid,'object',obj,'fieldname','latentheat','format','Double');
     105                        WriteData(fid,'object',obj,'fieldname','thermalconductivity','format','Double');
     106                        WriteData(fid,'object',obj,'fieldname','meltingpoint','format','Double');
     107                        WriteData(fid,'object',obj,'fieldname','beta','format','Double');
     108                        WriteData(fid,'object',obj,'fieldname','mixed_layer_capacity','format','Double');
     109                        WriteData(fid,'object',obj,'fieldname','thermal_exchange_velocity','format','Double');
     110                        WriteData(fid,'object',obj,'fieldname','rheology_B','format','DoubleMat','mattype',1);
     111                        WriteData(fid,'object',obj,'fieldname','rheology_n','format','DoubleMat','mattype',2);
     112                        WriteData(fid,'data',StringToEnum(obj.rheology_law),'enum',MaterialsRheologyLawEnum,'format','Integer');
     113                end % }}}
    106114        end
    107115end

  • issm/trunk-jpl/src/m/classes/mesh.m

    r9860 r10969  
    66classdef mesh
    77        properties (SetAccess=public)
    8                 x                           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 y                           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    10                 z                           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    11                 elements                    = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    12                 dimension                   = modelfield('default',0,'marshall',true,'format','Integer');
    13                 numberoflayers              = modelfield('default',0,'marshall',true,'format','Integer');
    14                 numberofelements            = modelfield('default',0,'marshall',true,'format','Integer');
    15                 numberofvertices            = modelfield('default',0,'marshall',true,'format','Integer');
    16                 numberofedges               = modelfield('default',0,'marshall',true,'format','Integer');
     8                x                           = NaN;
     9                y                           = NaN;
     10                z                           = NaN
     11                elements                    = NaN
     12                dimension                   = 0;
     13                numberoflayers              = 0;
     14                numberofelements            = 0;
     15                numberofvertices            = 0;
     16                numberofedges               = 0;
    1717               
    18                 lat                         = modelfield('default',NaN,'marshall',false);
    19                 long                        = modelfield('default',NaN,'marshall',false);
    20                 hemisphere                  = modelfield('default',NaN,'marshall',false);
    21 
    22                 elementonbed                = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    23                 elementonsurface            = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    24                 vertexonbed                 = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
    25                 vertexonsurface             = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
    26                 lowerelements               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    27                 lowervertex                 = modelfield('default',NaN,'marshall',false);
    28                 upperelements               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    29                 uppervertex                 = modelfield('default',NaN,'marshall',false);
    30                 vertexonboundary            = modelfield('default',NaN,'marshall',false);
    31 
    32                 edges                       = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    33                 segments                    = modelfield('default',NaN,'marshall',false);
    34                 segmentmarkers              = modelfield('default',NaN,'marshall',false);
    35                 vertexconnectivity          = modelfield('default',NaN,'marshall',false);
    36                 elementconnectivity         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    37                 average_vertex_connectivity = modelfield('default',0,'marshall',true,'format','Integer');
    38 
    39                 x2d                         = modelfield('default',NaN,'marshall',false);
    40                 y2d                         = modelfield('default',NaN,'marshall',false);
    41                 elements2d                  = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    42                 numberofvertices2d          = modelfield('default',0,'marshall',true,'format','Integer');
    43                 numberofelements2d          = modelfield('default',0,'marshall',true,'format','Integer');
    44 
    45                 extractedvertices           = modelfield('default',NaN,'marshall',false);
    46                 extractedelements           = modelfield('default',NaN,'marshall',false);
     18                lat                         = NaN
     19                long                        = NaN
     20                hemisphere                  = NaN
     21
     22                elementonbed                = NaN
     23                elementonsurface            = NaN
     24                vertexonbed                 = NaN
     25                vertexonsurface             = NaN
     26                lowerelements               = NaN
     27                lowervertex                 = NaN
     28                upperelements               = NaN
     29                uppervertex                 = NaN
     30                vertexonboundary            = NaN
     31
     32                edges                       = NaN
     33                segments                    = NaN
     34                segmentmarkers              = NaN
     35                vertexconnectivity          = NaN
     36                elementconnectivity         = NaN
     37                average_vertex_connectivity = 0;
     38
     39                x2d                         = NaN
     40                y2d                         = NaN
     41                elements2d                  = NaN
     42                numberofvertices2d          = 0;
     43                numberofelements2d          = 0;
     44
     45                extractedvertices           = NaN
     46                extractedelements           = NaN
    4747        end
    4848        methods
    … …  
    6363                end % }}}
    6464                function obj = setdefaultparameters(obj) % {{{
    65 
    66                         %first, use the defaults provided by the properties definition above.
    67                         fieldnames=fields(obj);
    68                         for i=1:length(fieldnames),
    69                                 fieldname=fieldnames{i};
    70                                 obj.(fieldname)=obj.(fieldname).default;
    71                         end
    7265
    7366                        %the connectivity is the avergaded number of nodes linked to a
    … …  
    183176                        fielddisplay(obj,'hemisphere','Indicate hemisphere ''n'' or ''s'' ');
    184177                end % }}}
     178                function marshall(obj,fid) % {{{
     179                        WriteData(fid,'object',obj,'fieldname','x','format','DoubleMat','mattype',1);
     180                        WriteData(fid,'object',obj,'fieldname','y','format','DoubleMat','mattype',1);
     181                        WriteData(fid,'object',obj,'fieldname','z','format','DoubleMat','mattype',1);
     182                        WriteData(fid,'object',obj,'fieldname','elements','format','DoubleMat','mattype',2);
     183                        WriteData(fid,'object',obj,'fieldname','dimension','format','Integer');
     184                        WriteData(fid,'object',obj,'fieldname','numberoflayers','format','Integer');
     185                        WriteData(fid,'object',obj,'fieldname','numberofelements','format','Integer');
     186                        WriteData(fid,'object',obj,'fieldname','numberofvertices','format','Integer');
     187                        WriteData(fid,'object',obj,'fieldname','numberofedges','format','Integer');
     188                        WriteData(fid,'object',obj,'fieldname','elementonbed','format','BooleanMat','mattype',2);
     189                        WriteData(fid,'object',obj,'fieldname','elementonsurface','format','BooleanMat','mattype',2);
     190                        WriteData(fid,'object',obj,'fieldname','vertexonbed','format','BooleanMat','mattype',1);
     191                        WriteData(fid,'object',obj,'fieldname','vertexonsurface','format','BooleanMat','mattype',1);
     192                        WriteData(fid,'object',obj,'fieldname','lowerelements','format','DoubleMat','mattype',2);
     193                        WriteData(fid,'object',obj,'fieldname','upperelements','format','DoubleMat','mattype',2);
     194                        WriteData(fid,'object',obj,'fieldname','edges','format','DoubleMat','mattype',3);
     195                        WriteData(fid,'object',obj,'fieldname','elementconnectivity','format','DoubleMat','mattype',3);
     196                        WriteData(fid,'object',obj,'fieldname','average_vertex_connectivity','format','Integer');
     197                        WriteData(fid,'object',obj,'fieldname','elements2d','format','DoubleMat','mattype',3);
     198                        WriteData(fid,'object',obj,'fieldname','numberofvertices2d','format','Integer');
     199                        WriteData(fid,'object',obj,'fieldname','numberofelements2d','format','Integer');
     200                end % }}}
    185201        end
    186202end

  • issm/trunk-jpl/src/m/classes/miscellaneous.m

    r9862 r10969  
    66classdef miscellaneous
    77        properties (SetAccess=public)
    8                 notes = modelfield('default','','marshall',false);
    9                 name  = modelfield('default','','marshall',true,'format','String');
    10                 dummy = modelfield('default',NaN,'marshall',false);
     8                notes = '';
     9                name  = '';
     10                dummy = struct();
    1111        end
    1212        methods
    … …  
    3333                function obj = setdefaultparameters(obj) % {{{
    3434
    35                         %first, use the defaults provided by the properties definition above.
    36                         fieldnames=fields(obj);
    37                         for i=1:length(fieldnames),
    38                                 fieldname=fieldnames{i};
    39                                 obj.(fieldname)=obj.(fieldname).default;
    40                         end
    4135                end % }}}
    4236                function disp(obj) % {{{
    … …  
    4842
    4943                end % }}}
     44                function marshall(obj,fid) % {{{
     45                        WriteData(fid,'object',obj,'fieldname','name','format','String');
     46                end % }}}
    5047        end
    5148end

  • issm/trunk-jpl/src/m/classes/model/model.m

    r10452 r10969  
    88                 % {{{1
    99                 %Careful here: no other class should be used as default value this is a bug of matlab
    10                  mesh             = modelfield('default',0,'marshall',true);
    11                  mask             = modelfield('default',0,'marshall',true);
    12 
    13                  geometry         = modelfield('default',0,'marshall',true);
    14                  constants        = modelfield('default',0,'marshall',true);
    15                  surfaceforcings  = modelfield('default',0,'marshall',true);
    16                  basalforcings    = modelfield('default',0,'marshall',true);
    17                  materials        = modelfield('default',0,'marshall',true);
    18                  friction         = modelfield('default',0,'marshall',true);
    19                  flowequation     = modelfield('default',0,'marshall',true);
    20                  timestepping     = modelfield('default',0,'marshall',true);
    21                  initialization   = modelfield('default',0,'marshall',true);
    22                  rifts            = modelfield('default',0,'marshall',true);
    23 
    24                  debug            = modelfield('default',0,'marshall',false);
    25                  verbose          = modelfield('default',0,'marshall',true,'preprocess','marshallverbose','format','Integer');
    26                  settings         = modelfield('default',0,'marshall',true);
    27                  solver           = modelfield('default',0,'marshall',false);
    28                  cluster          = modelfield('default',0,'marshall',false);
    29 
    30                  balancethickness = modelfield('default',0,'marshall',true);
    31                  diagnostic       = modelfield('default',0,'marshall',true);
    32                  groundingline    = modelfield('default',0,'marshall',true);
    33                  hydrology        = modelfield('default',0,'marshall',true);
    34                  prognostic       = modelfield('default',0,'marshall',true);
    35                  thermal          = modelfield('default',0,'marshall',true);
    36                  steadystate      = modelfield('default',0,'marshall',true);
    37                  transient        = modelfield('default',0,'marshall',true);
    38 
    39                  autodiff         = modelfield('default',0,'marshall',true);
    40                  flaim            = modelfield('default',0,'marshall',false);
    41                  inversion        = modelfield('default',0,'marshall',true);
    42                  qmu              = modelfield('default',0,'marshall',true);
    43 
    44                  results          = modelfield('default',0,'marshall',false);
    45                  radaroverlay     = modelfield('default',0,'marshall',false);
    46                  miscellaneous    = modelfield('default',0,'marshall',true);
    47                  private          = modelfield('default',0,'marshall',false);
     10                 mesh             = 0;
     11                 mask             = 0;
     12
     13                 geometry         = 0;
     14                 constants        = 0;
     15                 surfaceforcings  = 0;
     16                 basalforcings    = 0;
     17                 materials        = 0;
     18                 friction         = 0;
     19                 flowequation     = 0;
     20                 timestepping     = 0;
     21                 initialization   = 0;
     22                 rifts            = 0;
     23
     24                 debug            = 0;
     25                 verbose          = 0;
     26                 settings         = 0;
     27                 solver           = 0;
     28                 cluster          = 0;
     29
     30                 balancethickness = 0;
     31                 diagnostic       = 0;
     32                 groundingline    = 0;
     33                 hydrology        = 0;
     34                 prognostic       = 0;
     35                 thermal          = 0;
     36                 steadystate      = 0;
     37                 transient        = 0;
     38
     39                 autodiff         = 0;
     40                 flaim            = 0;
     41                 inversion        = 0;
     42                 qmu              = 0;
     43
     44                 results          = 0;
     45                 radaroverlay     = 0;
     46                 miscellaneous    = 0;
     47                 private          = 0;
    4848
    4949                 %}}}
    … …  
    388388                 function md = setdefaultparameters(md) % {{{1
    389389
    390                          %first, use the defaults provided by the properties definition above.
    391                          fieldnames=fields(md);
    392                          for i=1:length(fieldnames),
    393                                  fieldname=fieldnames{i};
    394                                  md.(fieldname)=md.(fieldname).default;
    395                          end
    396 
    397390                         %initialize subclasses
    398                          md.cluster          = none;
    399                          md.solver           = solver;
     391                         md.mesh             = mesh();
     392                         md.mask             = mask();
     393                         md.constants        = constants();
     394                         md.geometry         = geometry();
     395                         md.initialization   = initialization();
     396                         md.surfaceforcings  = surfaceforcings();
     397                         md.basalforcings    = basalforcings();
     398                         md.friction         = friction();
     399                         md.rifts            = rifts();
     400                         md.timestepping     = timestepping();
     401                         md.groundingline    = groundingline();
     402                         md.materials        = materials();
     403                         md.flowequation     = flowequation();
     404                         md.debug            = debug();
     405                         md.verbose          = verbose('solution',true,'qmu',true,'control',true);
     406                         md.settings         = settings();
     407                         md.solver           = solver();
    400408                         md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum,mumpsoptions);
     409                         md.cluster          = none();
     410                         md.balancethickness = balancethickness();
     411                         md.diagnostic       = diagnostic();
     412                         md.hydrology        = hydrology();
     413                         md.prognostic       = prognostic();
     414                         md.thermal          = thermal();
     415                         md.steadystate      = steadystate();
     416                         md.transient        = transient();
     417                         md.autodiff         = autodiff();
     418                         md.flaim            = flaim();
     419                         md.inversion        = inversion();
     420                         md.qmu              = qmu();
     421                         md.radaroverlay     = radaroverlay();
    401422                         md.results          = struct();
    402                          md.debug            = debug;
    403                          md.constants        = constants;
    404                          md.flaim            = flaim;
    405                          md.surfaceforcings  = surfaceforcings;
    406                          md.basalforcings    = basalforcings;
    407                          md.friction         = friction;
    408                          md.private          = private;
    409                          md.rifts            = rifts;
    410                          md.hydrology        = hydrology;
    411                          md.settings         = settings;
    412                          md.radaroverlay     = radaroverlay;
    413                          md.thermal          = thermal;
    414                          md.miscellaneous    = miscellaneous;
    415                          md.timestepping     = timestepping;
    416                          md.groundingline    = groundingline;
    417                          md.prognostic       = prognostic;
    418                          md.materials        = materials;
    419                          md.mask             = mask;
    420                          md.qmu              = qmu;
    421                          md.balancethickness = balancethickness;
    422                          md.flowequation     = flowequation;
    423                          md.steadystate      = steadystate;
    424                          md.inversion        = inversion;
    425                          md.transient        = transient;
    426                          md.diagnostic       = diagnostic;
    427                          md.initialization   = initialization;
    428                          md.geometry         = geometry;
    429                          md.verbose          = verbose('solution',true,'qmu',true,'control',true);
    430                          md.autodiff         = autodiff;
    431                          md.mesh             = mesh;
     423                         md.miscellaneous    = miscellaneous();
     424                         md.private          = private();
    432425                 end
    433426                 %}}}

  • issm/trunk-jpl/src/m/classes/private.m

    r9853 r10969  
    66classdef private
    77        properties (SetAccess=public)
    8                  runtimename = modelfield('default','','marshall',false);
    9                  bamg        = modelfield('default',0,'marshall',false);
    10                  solution    = modelfield('default','','marshall',false);
     8                 runtimename = '';
     9                 bamg        = struct();
     10                 solution    = '';
    1111        end
    1212        methods
    … …  
    2828                function obj = setdefaultparameters(obj) % {{{
    2929
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    36 
    3730                end % }}}
    3831                function checkconsistency(obj,md,solution,analyses) % {{{

  • issm/trunk-jpl/src/m/classes/prognostic.m

    r9862 r10969  
    66classdef prognostic
    77        properties (SetAccess=public)
    8                  spcthickness           = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                  hydrostatic_adjustment = modelfield('default',0,'marshall',true,'preprocess','StringToEnum','format','Integer');
    10                  stabilization          = modelfield('default',0,'marshall',true,'format','Integer');
    11                  vertex_pairing         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    12                  penalty_factor         = modelfield('default',0,'marshall',true,'format','Double');
     8                 spcthickness           = NaN;
     9                 hydrostatic_adjustment = 0;
     10                 stabilization          = 0;
     11                 vertex_pairing         = NaN;
     12                 penalty_factor         = 0;
    1313        end
    1414        methods
    … …  
    2929                end % }}}
    3030                function obj = setdefaultparameters(obj) % {{{
    31 
    32                         %first, use the defaults provided by the properties definition above.
    33                         fieldnames=fields(obj);
    34                         for i=1:length(fieldnames),
    35                                 fieldname=fieldnames{i};
    36                                 obj.(fieldname)=obj.(fieldname).default;
    37                         end
    3831
    3932                        %Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin
    … …  
    6760
    6861                end % }}}
     62                function marshall(obj,fid) % {{{
     63                        WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1);
     64                        WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum);
     65                        WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
     66                        WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
     67                        WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
     68                end % }}}
    6969        end
    7070end

  • issm/trunk-jpl/src/m/classes/qmu.m

    r10703 r10969  
    66classdef qmu
    77        properties (SetAccess=public)
    8                 isdakota                    = modelfield('default',0,'marshall',true,'format','Boolean');
    9                 variables                   = modelfield('default',struct(),'marshall',false);
    10                 responses                   = modelfield('default',struct(),'marshall',false);
    11                 method                      = modelfield('default',struct(),'marshall',false);
    12                 params                      = modelfield('default',struct(),'marshall',false);
    13                 results                     = modelfield('default',struct(),'marshall',false);
    14                 partition                   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    15                 numberofpartitions          = modelfield('default',0,'marshall',true,'format','Integer');
    16                 numberofresponses           = modelfield('default',0,'marshall',true,'format','Integer');
    17                 variabledescriptors         = modelfield('default',{},'marshall',true,'format','StringArray');
    18                 responsedescriptors         = modelfield('default',{},'marshall',true,'format','StringArray');
    19                 mass_flux_profile_directory = modelfield('default',NaN,'marshall',false);
    20                 mass_flux_profiles          = modelfield('default',NaN,'marshall',false);
    21                 mass_flux_segments          = modelfield('default',{},'marshall',true,'format','MatArray');
    22                 adjacency                   = modelfield('default',NaN,'marshall',false);
    23                 vertex_weight               = modelfield('default',NaN,'marshall',false);
     8                isdakota                    = 0;
     9                variables                   = struct();
     10                responses                   = struct();
     11                method                      = struct();
     12                params                      = struct();
     13                results                     = struct();
     14                partition                   = NaN;
     15                numberofpartitions          = 0;
     16                numberofresponses           = 0;
     17                variabledescriptors         = {};
     18                responsedescriptors         = {};
     19                mass_flux_profile_directory = NaN;
     20                mass_flux_profiles          = NaN;
     21                mass_flux_segments          = {};
     22                adjacency                   = NaN;
     23                vertex_weight               = NaN;
    2424        end
    2525        methods
    … …  
    4040                end % }}}
    4141                function obj = setdefaultparameters(obj) % {{{
    42 
    43                         %first, use the defaults provided by the properties definition above.
    44                         fieldnames=fields(obj);
    45                         for i=1:length(fieldnames),
    46                                 fieldname=fieldnames{i};
    47                                 obj.(fieldname)=obj.(fieldname).default;
    48                         end
     42       
    4943                end % }}}
    5044                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    165159
    166160                end % }}}
     161                function marshall(obj,fid) % {{{
     162                        WriteData(fid,'object',obj,'fieldname','isdakota','format','Boolean');
     163                        if ~obj.isdakota, return; end
     164                        WriteData(fid,'object',obj,'fieldname','partition','format','DoubleMat','mattype',2);
     165                        WriteData(fid,'object',obj,'fieldname','numberofpartitions','format','Integer');
     166                        WriteData(fid,'object',obj,'fieldname','numberofresponses','format','Integer');
     167                        WriteData(fid,'object',obj,'fieldname','variabledescriptors','format','StringArray');
     168                        WriteData(fid,'object',obj,'fieldname','responsedescriptors','format','StringArray');
     169                        WriteData(fid,'object',obj,'fieldname','mass_flux_segments','format','MatArray');
     170                end % }}}
    167171        end
    168172end

  • issm/trunk-jpl/src/m/classes/rifts.m

    r9862 r10969  
    66classdef rifts
    77        properties (SetAccess=public)
    8                 riftstruct     = modelfield('default',NaN,'marshall',true,'preprocess','marshallrifts','format','DoubleMat','mattype',3);
    9                 riftproperties = modelfield('default',NaN,'marshall',false);
    10                 numrifts       = modelfield('default',0,'marshall',true,'format','Integer');
     8                riftstruct     = NaN;
     9                riftproperties = NaN;
    1110        end
    1211        methods
    … …  
    2827                function obj = setdefaultparameters(obj) % {{{
    2928
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3629                end % }}}
    3730                function checkconsistency(obj,md,solution,analyses) % {{{
    38                         if obj.numrifts,
     31                        if isempty(obj.riftstruct) | isnans(obj.riftstruct),
     32                                numrifts=0;
     33                        else
     34                                numrifts=numel(obj.riftstruct);
     35                        end
     36                        if numrifts,
    3937                                if ~(md.mesh.dimension==2),
    4038                                        checkmessage(['model not consistent: models with rifts are only supported in 2d for now!']);
    … …  
    5048                        else
    5149                                if ~isnans(obj.riftstruct),
    52                                         checkmessage(['riftstruct shoud be NaN since obj.numrifts is 0!']);
     50                                        checkmessage(['riftstruct shoud be NaN since numrifts is 0!']);
    5351                                end
    5452                        end
    … …  
    6260
    6361                end % }}}
     62                function marshall(obj,fid) % {{{
     63
     64                        %Process rift info
     65                        if isempty(obj.riftstruct) | isnans(obj.riftstruct),
     66                                numrifts=0;
     67                        else
     68                                numrifts=numel(obj.riftstruct);
     69                        end
     70                        numpairs=0;
     71                        for i=1:numrifts,
     72                                numpairs=numpairs+size(obj.riftstruct(i).penaltypairs,1);
     73                        end
     74
     75                        % 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
     76                        data=zeros(numpairs,12);
     77                        count=1;
     78                        for i=1:numrifts,
     79                                numpairsforthisrift=size(obj.riftstruct(i).penaltypairs,1);
     80                                data(count:count+numpairsforthisrift-1,1:7)=obj.riftstruct(i).penaltypairs;
     81                                data(count:count+numpairsforthisrift-1,8)=obj.riftstruct(i).fill;
     82                                data(count:count+numpairsforthisrift-1,9)=obj.riftstruct(i).friction;
     83                                data(count:count+numpairsforthisrift-1,10)=obj.riftstruct(i).fraction;
     84                                data(count:count+numpairsforthisrift-1,11)=obj.riftstruct(i).fractionincrement;
     85                                data(count:count+numpairsforthisrift-1,12)=obj.riftstruct(i).state;
     86                                count=count+numpairsforthisrift;
     87                        end
     88
     89                        WriteData(fid,'data',numrifts,'enum',RiftsNumriftsEnum,'format','Integer');
     90                        WriteData(fid,'data',data,'enum',RiftsRiftstructEnum,'format','DoubleMat','mattype',3);
     91                end % }}}
    6492        end
    6593end

  • issm/trunk-jpl/src/m/classes/settings.m

    r9862 r10969  
    66classdef settings
    77        properties (SetAccess=public)
    8                 io_gather           = modelfield('default',0,'marshall',true,'format','Boolean');
    9                 lowmem              = modelfield('default',0,'marshall',true,'format','Boolean');
    10                 results_on_vertices = modelfield('default',0,'marshall',true,'format','Boolean');
    11                 output_frequency    = modelfield('default',0,'marshall',true,'format','Integer');
    12                 waitonlock          = modelfield('default',0,'marshall',true,'format','Boolean');
     8                io_gather           = 0;
     9                lowmem              = 0;
     10                results_on_vertices = 0;
     11                output_frequency    = 0;
     12                waitonlock          = 0;
    1313        end
    1414        methods
    … …  
    2929                end % }}}
    3030                function obj = setdefaultparameters(obj) % {{{
    31 
    32                         %first, use the defaults provided by the properties definition above.
    33                         fieldnames=fields(obj);
    34                         for i=1:length(fieldnames),
    35                                 fieldname=fieldnames{i};
    36                                 obj.(fieldname)=obj.(fieldname).default;
    37                         end
    3831
    3932                        %are we short in memory ? (0 faster but requires more memory)
    … …  
    7164
    7265                end % }}}
     66                function marshall(obj,fid) % {{{
     67                        WriteData(fid,'object',obj,'fieldname','io_gather','format','Boolean');
     68                        WriteData(fid,'object',obj,'fieldname','lowmem','format','Boolean');
     69                        WriteData(fid,'object',obj,'fieldname','results_on_vertices','format','Boolean');
     70                        WriteData(fid,'object',obj,'fieldname','output_frequency','format','Integer');
     71                        WriteData(fid,'object',obj,'fieldname','waitonlock','format','Boolean');
     72                end % }}}
    7373        end
    7474end

  • issm/trunk-jpl/src/m/classes/steadystate.m

    r9853 r10969  
    66classdef steadystate
    77        properties (SetAccess=public)
    8                 reltol            = modelfield('default',0,'marshall',true,'format','Double');
    9                 maxiter           = modelfield('default',0,'marshall',true,'format','Integer');
    10                 requested_outputs = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
     8                reltol            = 0;
     9                maxiter           = 0;
     10                requested_outputs = NaN;
    1111        end
    1212        methods
    … …  
    2727                end % }}}
    2828                function obj = setdefaultparameters(obj) % {{{
    29 
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    36 
    3729                        %maximum of steady state iterations
    3830                        obj.maxiter=100;
    … …  
    6254
    6355                end % }}}
     56                function marshall(obj,fid) % {{{
     57                        WriteData(fid,'object',obj,'fieldname','reltol','format','Double');
     58                        WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
     59                        WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3);
     60                end % }}}
    6461        end
    6562end

  • issm/trunk-jpl/src/m/classes/surfaceforcings.m

    r9862 r10969  
    66classdef surfaceforcings
    77        properties (SetAccess=public)
    8                 accumulation_rate = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 ablation_rate     = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    10                 mass_balance      = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
     8                accumulation_rate = NaN;
     9                ablation_rate     = NaN;
     10                mass_balance      = NaN;
    1111        end
    1212        methods
    … …  
    2828                function obj = setdefaultparameters(obj) % {{{
    2929
    30                         %first, use the defaults provided by the properties definition above.
    31                         fieldnames=fields(obj);
    32                         for i=1:length(fieldnames),
    33                                 fieldname=fieldnames{i};
    34                                 obj.(fieldname)=obj.(fieldname).default;
    35                         end
    3630                end % }}}
    3731                function checkconsistency(obj,md,solution,analyses) % {{{
    … …  
    5246
    5347                end % }}}
     48                function marshall(obj,fid) % {{{
     49                        WriteData(fid,'object',obj,'fieldname','accumulation_rate','format','DoubleMat','mattype',1);
     50                        WriteData(fid,'object',obj,'fieldname','ablation_rate','format','DoubleMat','mattype',1);
     51                        WriteData(fid,'object',obj,'fieldname','mass_balance','format','DoubleMat','mattype',1);
     52                end % }}}
    5453        end
    5554end

  • issm/trunk-jpl/src/m/classes/thermal.m

    r9862 r10969  
    66classdef thermal
    77        properties (SetAccess=public)
    8                 spctemperature    = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    9                 penalty_threshold = modelfield('default',0,'marshall',true,'format','Integer');
    10                 stabilization     = modelfield('default',0,'marshall',true,'format','Integer');
    11                 maxiter           = modelfield('default',0,'marshall',true,'format','Integer');
    12                 penalty_lock      = modelfield('default',0,'marshall',true,'format','Integer');
    13                 penalty_factor    = modelfield('default',0,'marshall',true,'format','Double');
     8                spctemperature    = NaN;
     9                penalty_threshold = 0;
     10                stabilization     = 0;
     11                maxiter           = 0;
     12                penalty_lock      = 0;
     13                penalty_factor    = 0;
    1414        end
    1515        methods
    … …  
    3030                end % }}}
    3131                function obj = setdefaultparameters(obj) % {{{
    32 
    33                         %first, use the defaults provided by the properties definition above.
    34                         fieldnames=fields(obj);
    35                         for i=1:length(fieldnames),
    36                                 fieldname=fieldnames{i};
    37                                 obj.(fieldname)=obj.(fieldname).default;
    38                         end
    3932
    4033                        %Number of unstable constraints acceptable
    … …  
    6861
    6962                end % }}}
     63                function marshall(obj,fid) % {{{
     64                        WriteData(fid,'object',obj,'fieldname','spctemperature','format','DoubleMat','mattype',1);
     65                        WriteData(fid,'object',obj,'fieldname','penalty_threshold','format','Integer');
     66                        WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
     67                        WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
     68                        WriteData(fid,'object',obj,'fieldname','penalty_lock','format','Integer');
     69                        WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
     70                end % }}}
    7071        end
    7172end

  • issm/trunk-jpl/src/m/classes/timestepping.m

    r9862 r10969  
    66classdef timestepping
    77        properties (SetAccess=public)
    8                 time_step       = modelfield('default',0,'marshall',true,'format','Double');
    9                 final_time      = modelfield('default',0,'marshall',true,'format','Double');
    10                 time_adapt      = modelfield('default',0,'marshall',true,'format','Boolean');
    11                 cfl_coefficient = modelfield('default',0,'marshall',true,'format','Double');
     8                time_step       = 0;
     9                final_time      = 0;
     10                time_adapt      = 0;
     11                cfl_coefficient = 0;
    1212        end
    1313        methods
    … …  
    2828                end % }}}
    2929                function obj = setdefaultparameters(obj) % {{{
    30 
    31                         %first, use the defaults provided by the properties definition above.
    32                         fieldnames=fields(obj);
    33                         for i=1:length(fieldnames),
    34                                 fieldname=fieldnames{i};
    35                                 obj.(fieldname)=obj.(fieldname).default;
    36                         end
    3730
    3831                        %time between 2 time steps
    … …  
    6053
    6154                end % }}}
     55                function marshall(obj,fid) % {{{
     56                        WriteData(fid,'object',obj,'fieldname','time_step','format','Double');
     57                        WriteData(fid,'object',obj,'fieldname','final_time','format','Double');
     58                        WriteData(fid,'object',obj,'fieldname','time_adapt','format','Boolean');
     59                        WriteData(fid,'object',obj,'fieldname','cfl_coefficient','format','Double');
     60                end % }}}
    6261        end
    6362end

  • issm/trunk-jpl/src/m/classes/transient.m

    r10882 r10969  
    66classdef transient
    77        properties (SetAccess=public)
    8                 isprognostic      = modelfield('default',0,'marshall',true,'format','Boolean');
    9                 isdiagnostic      = modelfield('default',0,'marshall',true,'format','Boolean');
    10                 isthermal         = modelfield('default',0,'marshall',true,'format','Boolean');
    11                 isgroundingline   = modelfield('default',0,'marshall',true,'format','Boolean');
    12                 requested_outputs = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
     8                isprognostic      = 0;
     9                isdiagnostic      = 0;
     10                isthermal         = 0;
     11                isgroundingline   = 0;
     12                requested_outputs = NaN;
    1313        end
    1414        methods
    … …  
    2929                end % }}}
    3030                function obj = setdefaultparameters(obj) % {{{
    31 
    32                         %first, use the defaults provided by the properties definition above.
    33                         fieldnames=fields(obj);
    34                         for i=1:length(fieldnames),
    35                                 fieldname=fieldnames{i};
    36                                 obj.(fieldname)=obj.(fieldname).default;
    37                         end
    3831
    3932                        %full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now
    … …  
    6558
    6659                end % }}}
     60                function marshall(obj,fid) % {{{
     61                        WriteData(fid,'object',obj,'fieldname','isprognostic','format','Boolean');
     62                        WriteData(fid,'object',obj,'fieldname','isdiagnostic','format','Boolean');
     63                        WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean');
     64                        WriteData(fid,'object',obj,'fieldname','isgroundingline','format','Boolean');
     65                        WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3);
     66                end % }}}
    6767        end
    6868end

  • issm/trunk-jpl/src/m/classes/verbose.m

    r9853 r10969  
    2323                % {{{1
    2424                %BEGINFIELDS
    25                 mprocessor=false;
    26                 module=false;
    27                 solution=false;
    28                 solver=false;
    29                 convergence=false;
    30                 control=false;
    31                 qmu=false;
     25                mprocessor  = false;
     26                module      = false;
     27                solution    = false;
     28                solver      = false;
     29                convergence = false;
     30                control     = false;
     31                qmu         = false;
    3232                %ENDFIELDS
    3333                % }}}
    … …  
    117117                end
    118118                %}}}
     119                function marshall(obj,fid) % {{{
     120                        WriteData(fid,'data',VerboseToBinary(obj),'enum',VerboseEnum,'format','Integer');
     121                end % }}}
    119122        end
    120123end

  • issm/trunk-jpl/src/m/model/marshall.m

    r9725 r10969  
    11function marshall(md)
    2 %MARSHALL - output JPL-package compatible binary file from @model md, for certain solution type.
     2%MARSHALL - output compatible binary file from @model md, for certain solution type.
    33%
    4 %   The routine creates a JPL-package compatible binary file from @model md
     4%   The routine creates a compatible binary file from @model md
    55%   This binary file will be used for parallel runs in JPL-package
    66%
    … …  
    1616end
    1717
    18 %automatically marshall model md, using template information available from an empty model class.
    19 template=model.template();
    20 MarshallObject(fid,template,md,'');
     18%Go through al model field check that it is a class and call checkconsistency
     19fields=properties(md);
     20for i=1:length(fields),
     21        field=fields{i};
     22
     23        %Some properties do not need to be marshalled
     24        if ismember(field,{'results' 'debug' 'radaroverlay' 'solver' 'cluster'  'flaim' 'private'}),
     25                continue;
     26        end
     27
     28        %Check that current field is an object
     29        if ~isobject(md.(field))
     30                checkmessage(['field ''' char(field) ''' is not an object']);
     31        end
     32
     33        %Marshall current object
     34        %disp(['marshalling ' field '...']);
     35        md.(field).marshall(fid);
     36end
    2137
    2238%close file
    … …  
    2541        error(['marshall error message: could not close file ' [md.miscellaneous.name '.bin']]);
    2642end
    27 
    28 function MarshallObject(fid,template,object,prefix) % {{{
    29 fields=fieldnames(template);
    30 for i=1:length(fields),
    31         fieldname=fields{i};
    32         if ~isa(template.(fieldname),'modelfield'),
    33                 %Recursive call
    34                 MarshallObject(fid,template.(fieldname),object.(fieldname),[prefix fieldname])
    35         elseif template.(fieldname).marshall,
    36                 if ~isempty(template.(fieldname).preprocess),
    37                         eval(['fieldvalue=' template.(fieldname).preprocess '(object.(fieldname));']);
    38                 else
    39                         fieldvalue=object.(fieldname);
    40                 end
    41 
    42                 %Capitalize for enums
    43                 fieldnamecap=fieldname;
    44                 fieldnamecap(1)=upper(fieldname(1));
    45                 prefixcap=prefix;
    46                 if ~isempty(prefix), prefixcap(1)=upper(prefix(1)); end
    47 
    48                 %Write Data
    49                 WriteData(fid,[prefixcap fieldnamecap],fieldvalue,template.(fieldname));
    50         end
    51 end
    52         % }}}
    53 function WriteData(fid,fieldname,fieldvalue,fieldprop) % {{{
    54 %WRITEDATA - write model field in binary file
    55 %
    56 %   Usage:
    57 %      WriteData(fid,fieldname,fieldvalue,fieldprop)
    58 %
    59 
    60 %first recover data, enum of the data and type of data
    61 data=fieldvalue;
    62 if fieldprop.enum==NoneEnum,
    63         enum=BuildEnum(fieldname);
    64 else
    65         %Field enum overloaded
    66         enum=fieldprop.enum;
    67 end
    68 data_type=fieldprop.format;
    69 
    70 if issparse(data),
    71         data=full(data);
    72 end
    73 
    74 %Ok! write the enum (name) to identify this record uniquely
    75 fwrite(fid,enum,'int');
    76 
    77 %Now, write the data itself.
    78 if     strcmpi(data_type,'Boolean'),% {{{
    79         if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
    80 
    81         %first write length of record
    82         fwrite(fid,4+4,'int');  %1 bool (disguised as an int)+code
    83 
    84         %write data code:
    85         fwrite(fid,TypeToCode(data_type),'int');
    86 
    87         %now write integer
    88         fwrite(fid,data,'int');  %send an int, not easy to send a bool
    89         % }}}
    90 elseif strcmpi(data_type,'Integer'), % {{{
    91         if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
    92 
    93         %first write length of record
    94         fwrite(fid,4+4,'int');  %1 integer + code
    95 
    96         %write data code:
    97         fwrite(fid,TypeToCode(data_type),'int');
    98 
    99         %now write integer
    100         fwrite(fid,data,'int');
    101         % }}}
    102 elseif strcmpi(data_type,'Double'), % {{{
    103         if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
    104 
    105         %first write length of record
    106         fwrite(fid,8+4,'int');  %1 double+code
    107 
    108         %write data code:
    109         fwrite(fid,TypeToCode(data_type),'int');
    110 
    111         %now write double
    112         fwrite(fid,data,'double');
    113         % }}}
    114 elseif strcmpi(data_type,'String'), % {{{
    115         %first write length of record
    116         fwrite(fid,length(data)+4+4,'int');  %string + string size + code
    117 
    118         %write data code:
    119         fwrite(fid,TypeToCode(data_type),'int');
    120 
    121         %now write string
    122         fwrite(fid,length(data),'int');
    123         fwrite(fid,data,'char');
    124         % }}}
    125 elseif strcmpi(data_type,'BooleanMat'), % {{{
    126 
    127         %matrix type:
    128         mattype=fieldprop.mattype;
    129 
    130         %Get size
    131         s=size(data);
    132         %if matrix = NaN, then do not write anything
    133         if (s(1)==1 & s(2)==1 & isnan(data)),
    134                 s(1)=0; s(2)=0;
    135         end
    136 
    137         %first write length of record
    138         fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
    139 
    140         %write data code and matrix type:
    141         fwrite(fid,TypeToCode(data_type),'int');
    142         fwrite(fid,mattype,'int');
    143 
    144         %now write matrix
    145         fwrite(fid,s(1),'int');
    146         fwrite(fid,s(2),'int');
    147         if s(1)*s(2),
    148                 fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
    149         end
    150         % }}}
    151 elseif strcmpi(data_type,'IntMat'), % {{{
    152 
    153         %matrix type:
    154         mattype=fieldtype{2};
    155 
    156         %Get size
    157         s=size(data);
    158         %if matrix = NaN, then do not write anything
    159         if (s(1)==1 & s(2)==1 & isnan(data)),
    160                 s(1)=0; s(2)=0;
    161         end
    162 
    163         %first write length of record
    164         fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
    165 
    166         %write data code and matrix type:
    167         fwrite(fid,TypeToCode(data_type),'int');
    168         fwrite(fid,mattype,'int');
    169 
    170         %now write matrix
    171         fwrite(fid,s(1),'int');
    172         fwrite(fid,s(2),'int');
    173         if s(1)*s(2),
    174                 fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
    175         end
    176         % }}}
    177 elseif strcmpi(data_type,'DoubleMat'), % {{{
    178 
    179         %matrix type:
    180         mattype=fieldprop.mattype;
    181 
    182         %Get size
    183         s=size(data);
    184         %if matrix = NaN, then do not write anything
    185         if (s(1)==1 & s(2)==1 & isnan(data)),
    186                 s(1)=0; s(2)=0;
    187         end
    188 
    189         %first write length of record
    190         fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
    191 
    192         %write data code and matrix type:
    193         fwrite(fid,TypeToCode(data_type),'int');
    194         fwrite(fid,mattype,'int');
    195 
    196         %now write matrix
    197         fwrite(fid,s(1),'int');
    198         fwrite(fid,s(2),'int');
    199         if s(1)*s(2),
    200                 fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
    201         end
    202         % }}}
    203 elseif strcmpi(data_type,'MatArray'), % {{{
    204 
    205         numrecords=numel(data);
    206 
    207         %first get length of record
    208         recordlength=4+4; %number of records + code
    209         for i=1:numrecords,
    210                 matrix=data{i};
    211                 s=size(matrix);
    212                 recordlength=recordlength+4*2+... %row and col of matrix
    213                         s(1)*s(2)*8; %matrix of doubles
    214         end
    215 
    216         %write length of record
    217         fwrite(fid,recordlength,'int');
    218 
    219         %write data code:
    220         fwrite(fid,TypeToCode(data_type),'int');
    221 
    222         %write data, first number of records
    223         fwrite(fid,numrecords,'int');
    224 
    225         %write each matrix:
    226         for i=1:numrecords,
    227                 matrix=data{i};
    228                 s=size(matrix);
    229                 fwrite(fid,s(1),'int');
    230                 fwrite(fid,s(2),'int');
    231                 fwrite(fid,matrix','double');
    232         end
    233         % }}}
    234 elseif strcmpi(data_type,'StringArray'), % {{{
    235 
    236         %first get length of string array:
    237         num=numel(data);
    238         %now get length of record:
    239         recordlength=4+4; %for length of array + code
    240         for i=1:num,
    241                 string=data{i};
    242                 recordlength=recordlength+4+length(string); %for each string
    243         end
    244 
    245         %write length of record
    246         fwrite(fid,recordlength,'int');
    247 
    248         %write data code:
    249         fwrite(fid,TypeToCode(data_type),'int');
    250 
    251         %now write length of string array
    252         fwrite(fid,num,'int');
    253 
    254         %now write the strings
    255         for i=1:num,
    256                 string=data{i};
    257                 fwrite(fid,length(string),'int');
    258                 fwrite(fid,string,'char');
    259         end
    260         % }}}
    261 else
    262         error(['WriteData error message: data type: ' num2str(data_type) ' not supported yet! (' EnumToString(enum) ')']);
    263 end
    264 % }}}
    265 function enum=BuildEnum(string) % {{{
    266 %BUILDENUM - build enum out of string
    267 %
    268 %   Usage:
    269 %      enum=BuildEnum(string)
    270 
    271 if findstr(string,'_'),
    272         indices=findstr(string,'_');
    273         for i=1:length(indices),
    274                 string(indices(i)+1)=upper(string(indices(i)+1));
    275         end
    276         string(indices)=[];
    277 end
    278 
    279 %take first letter of string and make it uppercase:
    280 string(1)=upper(string(1));
    281 
    282 %Get Enum
    283 enum=eval([string 'Enum']);
    284 % }}}
    285 function code=TypeToCode(data_type) % {{{1
    286 %This routine takes the data_type string, and hardcodes it into an integer, which
    287 %is passed along the record, in order to identify the nature of the dataset being
    288 %sent.
    289 if     strcmpi(data_type,'Boolean'),
    290         code=1;
    291 elseif strcmpi(data_type,'Integer'),
    292         code=2;
    293 elseif strcmpi(data_type,'Double'),
    294         code=3;
    295 elseif strcmpi(data_type,'String'),
    296         code=4;
    297 elseif strcmpi(data_type,'BooleanMat'),
    298         code=5;
    299 elseif strcmpi(data_type,'IntMat'),
    300         code=6;
    301 elseif strcmpi(data_type,'DoubleMat'),
    302         code=7;
    303 elseif strcmpi(data_type,'MatArray'),
    304         code=8;
    305 elseif strcmpi(data_type,'StringArray'),
    306         code=9;
    307 else
    308         error('TypeToCode error message: data type not supported yet!');
    309 end% }}}
    310 
    311 %FIXME Some processing, should be moved to the corresponding classes in the future
    312 function out=marshallverbose(in)
    313         out = VerboseToBinary(in);
    314 function out=marshallicefront(in)
    315         out=in;
    316         pos=find(in(:,end)==0); out(pos,end)=AirEnum;
    317         pos=find(in(:,end)==1); out(pos,end)=WaterEnum;
    318         pos=find(in(:,end)==2); out(pos,end)=IceEnum;
    319 
    320 function out=marshallrifts(in)
    321         if isempty(in) | isnans(in),
    322                 numrifts=0;
    323         else
    324                 numrifts=numel(in);
    325         end
    326         numpairs=0;
    327         for i=1:numrifts,
    328                 numpairs=numpairs+size(in(i).penaltypairs,1);
    329         end
    330 
    331         out=zeros(numpairs,12); % 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
    332 
    333         count=1;
    334         for i=1:numrifts,
    335                 numpairsforthisrift=size(in(i).penaltypairs,1);
    336                 out(count:count+numpairsforthisrift-1,1:7)=in(i).penaltypairs;
    337                 out(count:count+numpairsforthisrift-1,8)=in(i).fill;
    338                 out(count:count+numpairsforthisrift-1,9)=in(i).friction;
    339                 out(count:count+numpairsforthisrift-1,10)=in(i).fraction;
    340                 out(count:count+numpairsforthisrift-1,11)=in(i).fractionincrement;
    341                 out(count:count+numpairsforthisrift-1,12)=in(i).state;
    342                 count=count+numpairsforthisrift;
    343         end
    344 function out=marshallapproximations(in),
    345         out=in;
    346         pos=find(in==0); out(pos,end)=NoneApproximationEnum;
    347         pos=find(in==1); out(pos,end)=HutterApproximationEnum;
    348         pos=find(in==2); out(pos,end)=MacAyealApproximationEnum;
    349         pos=find(in==3); out(pos,end)=PattynApproximationEnum;
    350         pos=find(in==4); out(pos,end)=StokesApproximationEnum;
    351         pos=find(in==5); out(pos,end)=MacAyealPattynApproximationEnum;
    352         pos=find(in==6); out(pos,end)=MacAyealStokesApproximationEnum;
    353         pos=find(in==7); out(pos,end)=PattynStokesApproximationEnum;
    354 
    355 function out=marshallcontroltype(in)
    356         out=zeros(1,numel(in));
    357         for i=1:numel(in),
    358                 out(i)=StringToEnum(in{i});
    359         end
    360 function out=marshallcmresponses(in),
    361         out=in;
    362         pos=find(in==101); out(pos)=SurfaceAbsVelMisfitEnum;
    363         pos=find(in==102); out(pos)=SurfaceRelVelMisfitEnum;
    364         pos=find(in==103); out(pos)=SurfaceLogVelMisfitEnum;
    365         pos=find(in==104); out(pos)=SurfaceLogVxVyMisfitEnum;
    366         pos=find(in==105); out(pos)=SurfaceAverageVelMisfitEnum;
    367         pos=find(in==201); out(pos)=ThicknessAbsMisfitEnum;
    368         pos=find(in==501); out(pos)=DragCoefficientAbsGradientEnum;
    369         pos=find(in==502); out(pos)=RheologyBbarAbsGradientEnum;
    370         pos=find(in==503); out(pos)=ThicknessAbsGradientEnum;

  • issm/trunk-jpl/src/m/model/solve.m

    r10286 r10969  
    5252end
    5353
    54 %preprocesses model before solving
    55 md=presolve(md);
    56 
    5754%Save model as is (in case of a crash)
    5855assignin('base',inputname(1),md);
Note: See TracChangeset for help on using the changeset viewer.