Changeset 17079


Ignore:
Timestamp:
01/09/14 11:55:33 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: deleted surfaceforcings class, now users need to decide what surfaceforcings class they want to use (SMB, SMBgradients, SMBpdd and more to come)

Location:
issm/trunk-jpl/src/m/classes
Files:
1 deleted
14 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    r17074 r17079  
    1515                                        error('constructor not supported');
    1616                        end
     17                end % }}}
     18                function self = extrude(self,md) % {{{
     19
     20                        self.mass_balance=project3d(md,'vector',self.mass_balance,'type','node');
     21
    1722                end % }}}
    1823                function self = initialize(self,md) % {{{

  • issm/trunk-jpl/src/m/classes/SMB.py

    r17074 r17079  
    22from EnumDefinitions import *
    33from checkfield import *
     4from project3d import *
    45from WriteData import *
    56
    … …  
    2021                return string
    2122                #}}}
     23        def extrude(self,md): # {{{
     24
     25                self.mass_balance=project3d(md,'vector',self.mass_balance,'type','node');
     26                return self
     27        #}}}
    2228        def initialize(self,md): # {{{
    2329

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

    r17078 r17079  
    1919                                        error('constructor not supported');
    2020                        end
     21                end % }}}
     22                function self = extrude(self,md) % {{{
     23
     24                        %Nothing for now
     25
    2126                end % }}}
    2227                function self = initialize(self,md) % {{{

  • issm/trunk-jpl/src/m/classes/SMBgradients.py

    r17078 r17079  
    22from EnumDefinitions import *
    33from checkfield import *
     4from project3d import *
    45from WriteData import *
    56
    … …  
    2930                return string
    3031                #}}}
     32        def extrude(self,md): # {{{
     33
     34                #Nothing for now
     35                return self
     36        #}}}
    3137        def initialize(self,md): # {{{
    3238

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

    r17078 r17079  
    2525                                        error('constructor not supported');
    2626                        end
     27                end % }}}
     28                function self = extrude(self,md) % {{{
     29
     30                        self.precipitation=project3d(md,'vector',self.precipitation,'type','node');
     31                        self.monthlytemperatures=project3d(md,'vector',self.monthlytemperatures,'type','node');
     32                        if(self.isdelta18o),self.temperatures_lgm=project3d(md,'vector',self.temperatures_lgm,'type','node');end
     33                        if(self.isdelta18o),self.temperatures_presentday=project3d(md,'vector',self.temperatures_presentday,'type','node');end
     34                        if(self.isdelta18o),self.precipitations_presentday=project3d(md,'vector',self.precipitations_presentday,'type','node');end
     35
     36
    2737                end % }}}
    2838                function self = initialize(self,md) % {{{

  • issm/trunk-jpl/src/m/classes/SMBpdd.py

    r17078 r17079  
    22from EnumDefinitions import *
    33from checkfield import *
     4from project3d import *
    45from WriteData import *
    56
    … …  
    4344                return string
    4445                #}}}
     46        def extrude(self,md): # {{{
     47
     48                self.precipitation=project3d(md,'vector',self.precipitation,'type','node');
     49                self.monthlytemperatures=project3d(md,'vector',self.monthlytemperatures,'type','node');
     50                if self.isdelta18o: self.temperatures_lgm=project3d(md,'vector',self.temperatures_lgm,'type','node')
     51                if self.isdelta18o: self.temperatures_presentday=project3d(md,'vector',self.temperatures_presentday,'type','node')
     52                if self.isdelta18o: self.precipitations_presentday=project3d(md,'vector',self.precipitations_presentday,'type','node')
     53                return self
     54        #}}}
    4555        def initialize(self,md): # {{{
    4656

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

    r17022 r17079  
    103103                        if ~isa(md.outputdefinition,'outputdefinition'),
    104104                                md.outputdefinition=outputdefinition();
     105                        end
     106                        %2014 January 9th
     107                        if isa(md.surfaceforcings,'surfaceforcings'),
     108                                disp('Recovering old surfaceforcings class');
     109                                mass_balance=md.surfaceforcings.mass_balance;
     110                                md.surfaceforcings=SMB();
     111                                md.surfaceforcings.mass_balance=mass_balance;
    105112                        end
    106113                end% }}}
    … …  
    673680                        md.inversion.vel_obs=project3d(md,'vector',md.inversion.vel_obs,'type','node');
    674681                        md.inversion.thickness_obs=project3d(md,'vector',md.inversion.thickness_obs,'type','node');
    675                         md.surfaceforcings.mass_balance=project3d(md,'vector',md.surfaceforcings.mass_balance,'type','node');
    676                         md.surfaceforcings.precipitation=project3d(md,'vector',md.surfaceforcings.precipitation,'type','node');
     682                        md.surfaceforcings = extrude(md.surfaceforcings,md);
    677683                        md.balancethickness.thickening_rate=project3d(md,'vector',md.balancethickness.thickening_rate,'type','node');
    678                         md.surfaceforcings.monthlytemperatures=project3d(md,'vector',md.surfaceforcings.monthlytemperatures,'type','node');
    679684
    680685                        %results
    … …  
    760765                        if ~isnan(md.inversion.max_parameters),md.inversion.max_parameters=project3d(md,'vector',md.inversion.max_parameters,'type','node');end;
    761766                        if ~isnan(md.qmu.partition),md.qmu.partition=project3d(md,'vector',md.qmu.partition','type','node');end
    762                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.temperatures_lgm=project3d(md,'vector',md.surfaceforcings.temperatures_lgm,'type','node');end
    763                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.temperatures_presentday=project3d(md,'vector',md.surfaceforcings.temperatures_presentday,'type','node');end
    764                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.precipitations_presentday=project3d(md,'vector',md.surfaceforcings.precipitations_presentday,'type','node');end
    765767
    766768                        %Put lithostatic pressure if there is an existing pressure
    … …  
    10641066                        md.geometry         = geometry();
    10651067                        md.initialization   = initialization();
    1066                         md.surfaceforcings  = surfaceforcings();
     1068                        md.surfaceforcings  = SMB();
    10671069                        md.basalforcings    = basalforcings();
    10681070                        md.friction         = friction();
    … …  
    10791081                        md.cluster          = generic();
    10801082                        md.balancethickness = balancethickness();
    1081                         md.stressbalance       = stressbalance();
     1083                        md.stressbalance    = stressbalance();
    10821084                        md.hydrology        = hydrologyshreve();
    1083                         md.masstransport       = masstransport();
     1085                        md.masstransport    = masstransport();
    10841086                        md.thermal          = thermal();
    10851087                        md.steadystate      = steadystate();

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

    r17078 r17079  
    6060                self.geometry         = geometry()
    6161                self.constants        = constants()
    62                 self.surfaceforcings  = surfaceforcings()
     62                self.surfaceforcings  = SMB()
    6363                self.basalforcings    = basalforcings()
    6464                self.materials        = matice()
    … …  
    576576                md.inversion.vel_obs=project3d(md,'vector',md.inversion.vel_obs,'type','node')
    577577                md.inversion.thickness_obs=project3d(md,'vector',md.inversion.thickness_obs,'type','node')
    578                 md.surfaceforcings.mass_balance=project3d(md,'vector',md.surfaceforcings.mass_balance,'type','node')
    579                 md.surfaceforcings.precipitation=project3d(md,'vector',md.surfaceforcings.precipitation,'type','node')
     578                md.surfaceforcings.extrude(md)
    580579                md.balancethickness.thickening_rate=project3d(md,'vector',md.balancethickness.thickening_rate,'type','node')
    581                 md.surfaceforcings.monthlytemperatures=project3d(md,'vector',md.surfaceforcings.monthlytemperatures,'type','node')
    582580
    583581                #results
    … …  
    662660                if not numpy.any(numpy.isnan(md.qmu.partition)):
    663661                        md.qmu.partition=project3d(md,'vector',numpy.transpose(md.qmu.partition),'type','node')
    664                 if(md.surfaceforcings.isdelta18o):
    665                         md.surfaceforcings.temperatures_lgm=project3d(md,'vector',md.surfaceforcings.temperatures_lgm,'type','node')
    666                 if(md.surfaceforcings.isdelta18o):
    667                         md.surfaceforcings.temperatures_presentday=project3d(md,'vector',md.surfaceforcings.temperatures_presentday,'type','node')
    668                 if(md.surfaceforcings.isdelta18o):
    669                         md.surfaceforcings.precipitations_presentday=project3d(md,'vector',md.surfaceforcings.precipitations_presentday,'type','node')
    670662
    671663                #Put lithostatic pressure if there is an existing pressure

  • issm/trunk-jpl/src/m/classes/oldclasses/README

    r13239 r17079  
    11We put here all old classes so that matlab can still load old models
    22When an object is renamed or deleted, matlab is not able to load it
    3 anymore. We keep it here so that matlab can load the object
     3anymore. We keep it here so that matlab can load the object (just remove all
     4methods)

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

    r15987 r17079  
    2626                requested_outputs        = NaN;
    2727        end
    28         methods
    29                 function obj = diagnostic(varargin) % {{{
    30                         switch nargin
    31                                 case 0
    32                                         obj=setdefaultparameters(obj);
    33                                 otherwise
    34                                         error('constructor not supported');
    35                         end
    36                 end % }}}
    37                 function obj = setdefaultparameters(obj) % {{{
    38 
    39                          %maximum of non-linear iterations.
    40                          obj.maxiter=100;
    41 
    42                          %Convergence criterion: absolute, relative and residual
    43                          obj.restol=10^-4;
    44                          obj.reltol=0.01;
    45                          obj.abstol=10;
    46 
    47                          obj.FSreconditioning=10^13;
    48                          obj.shelf_dampening=0;
    49 
    50                          %Penalty factor applied kappa=max(stiffness matrix)*10^penalty_factor
    51                          obj.penalty_factor=3;
    52 
    53                          %coefficient to update the viscosity between each iteration of
    54                          %a diagnostic according to the following formula
    55                          %viscosity(n)=viscosity(n)+viscosity_overshoot(viscosity(n)-viscosity(n-1))
    56                          obj.viscosity_overshoot=0;
    57 
    58                          %Stop the iterations of rift if below a threshold
    59                          obj.rift_penalty_threshold=0;
    60 
    61                          %in some solutions, it might be needed to stop a run when only
    62                          %a few constraints remain unstable. For thermal computation, this
    63                          %parameter is often used.
    64                          obj.rift_penalty_lock=10;
    65 
    66                 end % }}}
    67                 function disp(obj) % {{{
    68 
    69                         disp(sprintf('   Stressbalance solution parameters:'));
    70 
    71                         disp(sprintf('\n      %s','Convergence criteria:'));
    72                         fielddisplay(obj,'restol','mechanical equilibrium residual convergence criterion');
    73                         fielddisplay(obj,'reltol','velocity relative convergence criterion, NaN: not applied');
    74                         fielddisplay(obj,'abstol','velocity absolute convergence criterion, NaN: not applied');
    75                         fielddisplay(obj,'isnewton','0: Picard''s fixed point, 1: Newton''s method, 2: hybrid');
    76                         fielddisplay(obj,'maxiter','maximum number of nonlinear iterations');
    77                         fielddisplay(obj,'viscosity_overshoot','over-shooting constant new=new+C*(new-old)');
    78 
    79                         disp(sprintf('\n      %s','boundary conditions:'));
    80                         fielddisplay(obj,'spcvx','x-axis velocity constraint (NaN means no constraint) [m/yr]');
    81                         fielddisplay(obj,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/yr]');
    82                         fielddisplay(obj,'spcvz','z-axis velocity constraint (NaN means no constraint) [m/yr]');
    83                         fielddisplay(obj,'icefront','segments on ice front list (last column 0: Air, 1: Water, 2: Ice)');
    84 
    85                         disp(sprintf('\n      %s','Rift options:'));
    86                         fielddisplay(obj,'rift_penalty_threshold','threshold for instability of mechanical constraints');
    87                         fielddisplay(obj,'rift_penalty_lock','number of iterations before rift penalties are locked');
    88 
    89                         disp(sprintf('\n      %s','Penalty options:'));
    90                         fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
    91                         fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized');
    92 
    93                         disp(sprintf('\n      %s','Other:'));
    94                         fielddisplay(obj,'shelf_dampening','use dampening for floating ice ? Only for FS model');
    95                         fielddisplay(obj,'FSreconditioning','multiplier for incompressibility equation. Only for FS model');
    96                         fielddisplay(obj,'referential','local referential');
    97                         fielddisplay(obj,'loadingforce','loading force applied on each point [N/m^3]');
    98                         fielddisplay(obj,'requested_outputs','additional outputs requested');
    99 
    100                 end % }}}
    101 
    102                 function marshall(obj,md,fid) % {{{
    103                         WriteData(fid,'object',obj,'fieldname','spcvx','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    104                         WriteData(fid,'object',obj,'fieldname','spcvy','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    105                         WriteData(fid,'object',obj,'fieldname','spcvz','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    106                         WriteData(fid,'object',obj,'fieldname','restol','format','Double');
    107                         WriteData(fid,'object',obj,'fieldname','reltol','format','Double');
    108                         WriteData(fid,'object',obj,'fieldname','abstol','format','Double');
    109                         WriteData(fid,'object',obj,'fieldname','isnewton','format','Integer');
    110                         WriteData(fid,'object',obj,'fieldname','FSreconditioning','format','Double');
    111                         WriteData(fid,'object',obj,'fieldname','viscosity_overshoot','format','Double');
    112                         WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
    113                         WriteData(fid,'object',obj,'fieldname','shelf_dampening','format','Integer');
    114                         WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
    115                         WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
    116                         WriteData(fid,'object',obj,'fieldname','rift_penalty_lock','format','Integer');
    117                         WriteData(fid,'object',obj,'fieldname','rift_penalty_threshold','format','Integer');
    118                         WriteData(fid,'object',obj,'fieldname','referential','format','DoubleMat','mattype',1);
    119                         WriteData(fid,'data',obj.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
    120                         WriteData(fid,'data',obj.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
    121                         WriteData(fid,'data',obj.loadingforce(:,3),'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
    122                         WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3);
    123 
    124                         %marshall ice front
    125                         data=obj.icefront;
    126                         pos=find(data(:,end)==0); data(pos,end)=AirEnum();
    127                         pos=find(data(:,end)==1); data(pos,end)=WaterEnum();
    128                         pos=find(data(:,end)==2); data(pos,end)=IceEnum();
    129                         WriteData(fid,'data',data,'enum',StressbalanceIcefrontEnum(),'format','DoubleMat','mattype',3);
    130                 end % }}}
    131         end
    13228end

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

    r15131 r17079  
    1414                stabilization  = 0;
    1515        end
    16         methods
    17                 function obj = hydrology(varargin) % {{{
    18                         switch nargin
    19                                 case 0
    20                                         obj=setdefaultparameters(obj);
    21                                 otherwise
    22                                         error('constructor not supported');
    23                         end
    24                 end % }}}
    25                 function obj = setdefaultparameters(obj) % {{{
    26 
    27                         %Parameters from Johnson's 2002 thesis, section 3.5.4                   
    28                         obj.n=.02;                       
    29                         obj.CR=.01;
    30                         obj.p=2;                 
    31                         obj.q=1;                 
    32                         obj.kn=0;
    33 
    34                         %Type of stabilization to use 0:nothing 1:artificial_diffusivity
    35                         obj.stabilization=1;
    36                 end % }}}
    37                 function md = checkconsistency(obj,md,solution,analyses) % {{{
    38 
    39                         %Early return
    40                         if ~ismember(HydrologyAnalysisEnum(),analyses), return; end
    41 
    42                         md = checkfield(md,'hydrology.spcwatercolumn','forcing',1);
    43                         md = checkfield(md,'hydrology.stabilization','>=',0);
    44                 end % }}}
    45                 function disp(obj) % {{{
    46                         disp(sprintf('   hydrology solution parameters:'));
    47 
    48                         fielddisplay(obj,'spcwatercolumn','water thickness constraints (NaN means no constraint)');
    49                         fielddisplay(obj,'n','Manning roughness coefficient');
    50                         fielddisplay(obj,'CR','tortuosity parameter');
    51                         fielddisplay(obj,'p','dimensionless exponent in Manning velocity formula');
    52                         fielddisplay(obj,'q','dimensionless exponent in Manning velocity formula');
    53                         fielddisplay(obj,'kn','parameter in effective pressure formula');
    54                         fielddisplay(obj,'stabilization','artificial diffusivity (default is 1). can be more than 1 to increase diffusivity.');
    55 
    56                 end % }}}
    57                 function marshall(obj,md,fid) % {{{
    58                         WriteData(fid,'object',obj,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1);
    59                         WriteData(fid,'object',obj,'fieldname','n','format','Double');
    60                         WriteData(fid,'object',obj,'fieldname','CR','format','Double');
    61                         WriteData(fid,'object',obj,'fieldname','p','format','Double');
    62                         WriteData(fid,'object',obj,'fieldname','q','format','Double');
    63                         WriteData(fid,'object',obj,'fieldname','kn','format','Double');
    64                         WriteData(fid,'object',obj,'fieldname','stabilization','format','Double');
    65                 end % }}}
    66         end
    6716end

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

    r15767 r17079  
    1414                 requested_outputs      = NaN;
    1515        end
    16         methods
    17                 function obj = prognostic(varargin) % {{{
    18                         switch nargin
    19                                 case 0
    20                                         obj=setdefaultparameters(obj);
    21                                 otherwise
    22                                         error('constructor not supported');
    23                         end
    24                 end % }}}
    25                 function obj = setdefaultparameters(obj) % {{{
    26 
    27                         %Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin
    28                         obj.stabilization=1;
    29 
    30                         %Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor
    31                         obj.penalty_factor=3;
    32 
    33                         %Minimum ice thickness that can be used
    34                         obj.min_thickness=1;
    35 
    36                         %Hydrostatic adjustment
    37                         obj.hydrostatic_adjustment='Absolute';
    38                 end % }}}
    39                 function md = checkconsistency(obj,md,solution,analyses) % {{{
    40 
    41                         %Early return
    42                         if ~ismember(PrognosticAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isprognostic==0), return; end
    43 
    44                         md = checkfield(md,'prognostic.spcthickness','forcing',1);
    45                         md = checkfield(md,'prognostic.hydrostatic_adjustment','values',{'Absolute' 'Incremental'});
    46                         md = checkfield(md,'prognostic.stabilization','values',[0 1 2 3]);
    47                         md = checkfield(md,'prognostic.min_thickness','>',0);
    48                         if ~isempty(md.prognostic.requested_outputs),
    49                                 md = checkfield(md,'prognostic.requested_outputs','size',[NaN 1]);
    50                         end
    51 
    52                 end % }}}
    53                 function disp(obj) % {{{
    54                         disp(sprintf('   Prognostic solution parameters:'));
    55                         fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]');
    56                         fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]');
    57                         fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' ');
    58                         fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin');
    59 
    60                         disp(sprintf('\n      %s','Penalty options:'));
    61                         fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
    62                         fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized');
    63                         fielddisplay(obj,'requested_outputs','additional outputs requested');
    64 
    65                 end % }}}
    66                 function marshall(obj,md,fid) % {{{
    67                         WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    68                         WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double');
    69                         WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum());
    70                         WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
    71                         WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
    72                         WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
    73                         WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3);
    74                 end % }}}
    75         end
    7616end

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

    r17078 r17079  
    2424                s0p                       = 0;
    2525        end
    26         methods
    27                 function obj = surfaceforcings(varargin) % {{{
    28                         switch nargin
    29                                 case 0
    30                                         obj=setdefaultparameters(obj);
    31                                 otherwise
    32                                         error('constructor not supported');
    33                         end
    34                 end % }}}
    35                 function self = initialize(self,md) % {{{
    36 
    37                         if (isnan(self.precipitation) & (self.ispdd==1)),
    38                                 self.precipitation=zeros(md.mesh.numberofvertices,1);
    39                                 disp('      no surfaceforcings.precipitation specified: values set as zero');
    40                         end
    41                         if (isnan(self.mass_balance) & (self.ispdd==0)),
    42                                 self.mass_balance=zeros(md.mesh.numberofvertices,1);
    43                                 disp('      no surfaceforcings.mass_balance specified: values set as zero');
    44                         end
    45 
    46                 end % }}}
    47                 function obj = setdefaultparameters(obj) % {{{
    48 
    49                   %pdd method not used in default mode
    50                   obj.ispdd=0;
    51                   obj.issmbgradients=0;
    52                   obj.isdelta18o=0;
    53                   obj.desfac=0.5;
    54                   obj.s0p=0;
    55                 end % }}}
    56                 function md = checkconsistency(obj,md,solution,analyses) % {{{
    57 
    58                         if ismember(MasstransportAnalysisEnum(),analyses),
    59                                 md = checkfield(md,'fieldname','surfaceforcings.ispdd','numel',[1],'values',[0 1]);
    60                                 md = checkfield(md,'fieldname','surfaceforcings.issmbgradients','numel',[1],'values',[0 1]);
    61                                 if(obj.ispdd)
    62                                   md = checkfield(md,'fieldname','surfaceforcings.desfac','<=',1,'numel',1);
    63                                   md = checkfield(md,'fieldname','surfaceforcings.s0p','>=',0,'numel',1);
    64                                         if(obj.isdelta18o==0)
    65                                                 md = checkfield(md,'fieldname','surfaceforcings.monthlytemperatures','forcing',1,'NaN',1);
    66                                                 md = checkfield(md,'fieldname','surfaceforcings.precipitation','forcing',1,'NaN',1);
    67                                         else
    68                                                 md = checkfield(md,'fieldname','surfaceforcings.delta18o','NaN',1);
    69                                                 md = checkfield(md,'fieldname','surfaceforcings.delta18o_surface','NaN',1);
    70                                                 md = checkfield(md,'fieldname','surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
    71                                                 md = checkfield(md,'fieldname','surfaceforcings.temperatures_lgm','size',[md.mesh.numberofvertices+1 12],'NaN',1);
    72                                                 md = checkfield(md,'fieldname','surfaceforcings.precipitations_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
    73                                         end
    74                                 elseif(obj.issmbgradients)
    75                                         md = checkfield(md,'fieldname','surfaceforcings.href','forcing',1,'NaN',1);
    76                                         md = checkfield(md,'fieldname','surfaceforcings.smbref','forcing',1,'NaN',1);
    77                                         md = checkfield(md,'fieldname','surfaceforcings.b_pos','forcing',1,'NaN',1);
    78                                         md = checkfield(md,'fieldname','surfaceforcings.b_neg','forcing',1,'NaN',1);
    79                                 else
    80                                         md = checkfield(md,'fieldname','surfaceforcings.mass_balance','forcing',1,'NaN',1);
    81                                 end
    82                         end
    83                         if ismember(BalancethicknessAnalysisEnum(),analyses),
    84                                 md = checkfield(md,'fieldname','surfaceforcings.mass_balance','size',[md.mesh.numberofvertices 1],'NaN',1);
    85                         end
    86                 end % }}}
    87                 function disp(obj) % {{{
    88                         disp(sprintf('   surface forcings parameters:'));
    89 
    90                         disp(sprintf('\n   General parameters:'));
    91                         fielddisplay(obj,'mass_balance','surface mass balance [m/yr ice eq]');
    92 
    93                         disp(sprintf('\n   PDD and deltaO18 parameters:'));
    94                         fielddisplay(obj,'ispdd','is pdd activated (0 or 1, default is 0)');
    95                         fielddisplay(obj,'isdelta18o','is temperature and precipitation delta18o parametrisation activated (0 or 1, default is 0)');
    96                         fielddisplay(obj,'desfac','desertification elevation factor (between 0 and 1, default is 0.5) [m]');
    97                         fielddisplay(obj,'s0p','should be set to elevation from precip source (between 0 and a few 1000s m, default is 0) [m]');
    98                         fielddisplay(obj,'monthlytemperatures','monthly surface temperatures [K], required if pdd is activated and delta18o not activated');
    99                         fielddisplay(obj,'precipitation','surface precipitation [m/yr water eq]');
    100                         fielddisplay(obj,'temperatures_presentday','monthly present day surface temperatures [K], required if pdd is activated and delta18o activated');
    101                         fielddisplay(obj,'temperatures_lgm','monthly LGM surface temperatures [K], required if pdd is activated and delta18o activated');
    102                         fielddisplay(obj,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if pdd is activated and delta18o activated');
    103                         fielddisplay(obj,'delta18o','delta18o, required if pdd is activated and delta18o activated');
    104                         fielddisplay(obj,'delta18o_surface','surface elevation of the delta18o site, required if pdd is activated and delta18o activated');
    105 
    106                         disp(sprintf('\n   SMB gradients parameters:'));
    107                         fielddisplay(obj,'issmbgradients','is smb gradients method activated (0 or 1, default is 0)');
    108                         fielddisplay(obj,'href',' reference elevation from which deviation is used to calculate SMB adjustment in smb gradients method');
    109                         fielddisplay(obj,'smbref',' reference smb from which deviation is calculated in smb gradients method');
    110                         fielddisplay(obj,'b_pos',' slope of hs - smb regression line for accumulation regime required if smb gradients is activated');
    111                         fielddisplay(obj,'b_neg',' slope of hs - smb regression line for ablation regime required if smb gradients is activated');
    112 
    113                 end % }}}
    114                 function marshall(obj,md,fid) % {{{
    115 
    116                         yts=365.0*24.0*3600.0;
    117 
    118                         WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SurfaceforcingsEnum(),'format','Integer');
    119 
    120                         WriteData(fid,'object',obj,'fieldname','precipitation','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    121                         WriteData(fid,'object',obj,'fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    122                         WriteData(fid,'object',obj,'fieldname','ispdd','format','Boolean');
    123                         WriteData(fid,'object',obj,'fieldname','isdelta18o','format','Boolean');
    124                         if obj.ispdd,
    125                                 WriteData(fid,'object',obj,'fieldname','desfac','format','Double');
    126                                 WriteData(fid,'object',obj,'fieldname','s0p','format','Double');
    127                                 if obj.isdelta18o
    128                                         WriteData(fid,'object',obj,'fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
    129                                         WriteData(fid,'object',obj,'fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
    130                                         WriteData(fid,'object',obj,'fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
    131                                         WriteData(fid,'object',obj,'fieldname','delta18o_surface','format','DoubleMat','mattype',1);
    132                                         WriteData(fid,'object',obj,'fieldname','delta18o','format','DoubleMat','mattype',1);
    133                                 else
    134                                         WriteData(fid,'object',obj,'fieldname','monthlytemperatures','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    135                                 end
    136                         end
    137                         WriteData(fid,'object',obj,'fieldname','issmbgradients','format','Boolean');
    138                         if obj.issmbgradients,
    139                                 WriteData(fid,'object',obj,'fieldname','href','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    140                                 WriteData(fid,'object',obj,'fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    141                                 WriteData(fid,'object',obj,'fieldname','b_pos','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    142                                 WriteData(fid,'object',obj,'fieldname','b_neg','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    143                         end
    144 
    145                 end % }}}
    146         end
    14726end

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

    r17075 r17079  
    66classdef transient
    77        properties (SetAccess=public)
    8                 ismasstransport      = 0;
    9                 isstressbalance      = 0;
     8                ismasstransport   = 0;
     9                isstressbalance   = 0;
    1010                isthermal         = 0;
    1111                isgroundingline   = 0;
    1212                isgia             = 0;
    13                 isdamage             = 0;
    14                 islevelset = 0;
     13                isdamage          = 0;
     14                islevelset        = 0;
    1515                requested_outputs = {};
    1616        end

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

    r17075 r17079  
    1313
    1414        def __init__(self): # {{{
    15                 self.ismasstransport      = False
    16                 self.isstressbalance      = False
     15                self.ismasstransport   = False
     16                self.isstressbalance   = False
    1717                self.isthermal         = False
    1818                self.isgroundingline   = False
Note: See TracChangeset for help on using the changeset viewer.