source: issm/oecreview/Archive/24684-25833/ISSM-24860-24861.diff

Last change on this file was 25834, checked in by Mathieu Morlighem, 4 years ago

CHG: added 24684-25833
File size: 88.8 KB

  • ../trunk-jpl/src/m/geometry/VolumeAboveFloatation.m

     
    3232V = areas.*(surface-base+min(rho_water/rho_ice*bathymetry,0.));
    3333
    3434%5. take out the ones that are outside of levelset or floating
    35 pos = find(min(md.mask.ice_levelset(index),[],2)>0 | min(md.mask.groundedice_levelset(index),[],2)<0);
     35pos = find(min(md.mask.ice_levelset(index),[],2)>0 | min(md.mask.ocean_levelset(index),[],2)<0);
    3636V(pos) = 0;
    3737
    3838%sum individual contributions

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

     
    5151        if(not m.strcmp(self.migration, 'None') and md.transient.isgroundingline and solution == 'TransientSolution'):
    5252            if np.any(np.isnan(md.geometry.bed)):
    5353                md.checkmessage("requesting grounding line migration, but bathymetry is absent!")
    54             pos = np.nonzero(md.mask.groundedice_levelset > 0.)[0]
     54            pos = np.nonzero(md.mask.ocean_levelset > 0.)[0]
    5555            if any(np.abs(md.geometry.base[pos] - md.geometry.bed[pos]) > 10**-10):
    5656                md.checkmessage("base not equal to bed on grounded ice!")
    5757            if any(md.geometry.bed - md.geometry.base > 10**-9):

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

     
    3636                                if isnan(md.geometry.bed),
    3737                                        md = checkmessage(md,['requesting grounding line migration, but bathymetry is absent!']);
    3838                                end
    39                                 pos=find(md.mask.groundedice_levelset>0. & md.mask.ice_levelset<=0);
     39                                pos=find(md.mask.ocean_levelset>0. & md.mask.ice_levelset<=0);
    4040                                if any(abs(md.geometry.base(pos)-md.geometry.bed(pos))>10^-10),
    4141                                        md = checkmessage(md,['base not equal to bed on grounded ice!']);
    4242                                end
    43                                 pos=find(md.mask.groundedice_levelset<=0. & md.mask.ice_levelset<=0);
     43                                pos=find(md.mask.ocean_levelset<=0. & md.mask.ice_levelset<=0);
    4444                                if any(md.geometry.bed(pos) - md.geometry.base(pos) > 10^-9),
    4545                                        md = checkmessage(md,['bed superior to base on floating ice!']);
    4646                                end

  • ../trunk-jpl/src/m/classes/maskpsl.m

     
    55
    66classdef maskpsl
    77        properties (SetAccess=public)
    8                 groundedice_levelset = NaN;
     8                ocean_levelset = NaN;
    99                ice_levelset         = NaN;
    1010                ocean_levelset = NaN;
    1111                land_levelset = NaN;
    … …  
    1919        end
    2020        methods
    2121                function self = extrude(self,md) % {{{
    22                         self.groundedice_levelset=project3d(md,'vector',self.groundedice_levelset,'type','node');
     22                        self.ocean_levelset=project3d(md,'vector',self.ocean_levelset,'type','node');
    2323                        self.ice_levelset=project3d(md,'vector',self.ice_levelset,'type','node');
    2424                        self.ocean_levelset=project3d(md,'vector',self.ocean_levelset,'type','node');
    2525                        self.land_levelset=project3d(md,'vector',self.land_levelset,'type','node');
    … …  
    3939                       
    4040                        if strcmpi(solution,'LoveSolution'), return; end;
    4141
    42                         md = checkfield(md,'fieldname','mask.groundedice_levelset','size',[md.mesh.numberofvertices 1]);
     42                        md = checkfield(md,'fieldname','mask.ocean_levelset','size',[md.mesh.numberofvertices 1]);
    4343                        md = checkfield(md,'fieldname','mask.ice_levelset'        ,'size',[md.mesh.numberofvertices 1]);
    4444                        md = checkfield(md,'fieldname','mask.ocean_levelset','size',[md.mesh.numberofvertices 1]);
    4545                        md = checkfield(md,'fieldname','mask.land_levelset','size',[md.mesh.numberofvertices 1]);
    … …  
    4646                end % }}}
    4747                function disp(self) % {{{
    4848                        disp(sprintf('   masks:'));
    49                         fielddisplay(self,'groundedice_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
     49                        fielddisplay(self,'ocean_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
    5050                        fielddisplay(self,'ice_levelset','presence of ice if < 0, icefront position if = 0, no ice if > 0');
    5151                        fielddisplay(self,'ocean_levelset','is the vertex on the ocean ? yes if = 1, no if = 0');
    5252                        fielddisplay(self,'land_levelset','is the vertex on the land ? yes if = 1, no if = 0');
    … …  
    5454                end % }}}
    5555                function marshall(self,prefix,md,fid) % {{{
    5656                        WriteData(fid,prefix,'name','md.mask.type','data',class(md.mask),'format','String');
    57                         WriteData(fid,prefix,'object',self,'class','mask','fieldname','groundedice_levelset','format','DoubleMat','mattype',1);
     57                        WriteData(fid,prefix,'object',self,'class','mask','fieldname','ocean_levelset','format','DoubleMat','mattype',1);
    5858                        WriteData(fid,prefix,'object',self,'class','mask','fieldname','ice_levelset','format','DoubleMat','mattype',1);
    5959                        WriteData(fid,prefix,'object',self,'class','mask','fieldname','ocean_levelset','format','DoubleMat','mattype',1);
    6060                        WriteData(fid,prefix,'object',self,'class','mask','fieldname','land_levelset','format','DoubleMat','mattype',1);
    … …  
    6161                end % }}}
    6262                function savemodeljs(self,fid,modelname) % {{{
    6363                        fprintf(fid,'%s.mask=new maskpsl();\n',modelname);
    64                         writejs1Darray(fid,[modelname '.mask.groundedice_levelset'],self.groundedice_levelset);
     64                        writejs1Darray(fid,[modelname '.mask.ocean_levelset'],self.ocean_levelset);
    6565                        writejs1Darray(fid,[modelname '.mask.ice_levelset'],self.ice_levelset);
    6666                        writejs1Darray(fid,[modelname '.mask.ocean_levelset'],self.ocean_levelset);
    6767                        writejs1Darray(fid,[modelname '.mask.land_levelset'],self.land_levelset);

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

     
    7171                                        if any(self.bed-self.base>10^-12),
    7272                                                md = checkmessage(md,['base<bed on one or more vertex']);
    7373                                        end
    74                                         pos = find(md.mask.groundedice_levelset>0);
     74                                        pos = find(md.mask.ocean_levelset>0);
    7575                                        if any(abs(self.bed(pos)-self.base(pos))>10^-9),
    7676                                                md = checkmessage(md,['equality base=bed on grounded ice violated']);
    7777                                        end

  • ../trunk-jpl/src/m/classes/stressbalance.m

     
    100100                                md = checkfield(md,'fieldname','stressbalance.vertex_pairing','>',0);
    101101                        end
    102102                        %singular solution
    103                         if ((~(any(~isnan(md.stressbalance.spcvx)) | any(~isnan(md.stressbalance.spcvy)))) & ~any(md.mask.groundedice_levelset>0)),
     103                        if ((~(any(~isnan(md.stressbalance.spcvx)) | any(~isnan(md.stressbalance.spcvy)))) & ~any(md.mask.ocean_levelset>0)),
    104104                                disp(sprintf('\n !!! Warning: no spc applied, model might not be well posed if no basal friction is applied, check for solution crash\n'));
    105105                        end
    106106                        %CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES
    … …  
    116116                        end
    117117                        %CHECK THAT NO rotation specified for FS Grounded ice at base
    118118                        if strcmp(domaintype(md.mesh),'3D') & md.flowequation.isFS,
    119                                 pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbase);
     119                                pos=find(md.mask.ocean_levelset>0. & md.mesh.vertexonbase);
    120120                                if any(~isnan(md.stressbalance.referential(pos,:))),
    121121                                        md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']);
    122122                                end

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

     
    55
    66classdef mask
    77        properties (SetAccess=public)
    8                 groundedice_levelset = NaN;
     8                ocean_levelset = NaN;
    99                ice_levelset         = NaN;
    1010        end
    1111        methods (Static)
    … …  
    2222        end
    2323        methods
    2424                function self = extrude(self,md) % {{{
    25                         self.groundedice_levelset=project3d(md,'vector',self.groundedice_levelset,'type','node');
     25                        self.ocean_levelset=project3d(md,'vector',self.ocean_levelset,'type','node');
    2626                        self.ice_levelset=project3d(md,'vector',self.ice_levelset,'type','node');
    2727                end % }}}
    2828                function self = mask(varargin) % {{{
    … …  
    3939                function md = checkconsistency(self,md,solution,analyses) % {{{
    4040                        if strcmpi(solution,'LoveSolution'), return; end;
    4141
    42                         md = checkfield(md,'fieldname','mask.groundedice_levelset','timeseries',1,'NaN',1);
     42                        md = checkfield(md,'fieldname','mask.ocean_levelset','timeseries',1,'NaN',1);
    4343                        md = checkfield(md,'fieldname','mask.ice_levelset','NaN',1,'size',[md.mesh.numberofvertices 1]);
    4444                        isice=(md.mask.ice_levelset<=0);
    4545                        if sum(isice)==0,
    … …  
    4949                function disp(self) % {{{
    5050                        disp(sprintf('   masks:'));
    5151
    52                         fielddisplay(self,'groundedice_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
     52                        fielddisplay(self,'ocean_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
    5353                        fielddisplay(self,'ice_levelset','presence of ice if < 0, icefront position if = 0, no ice if > 0');
    5454                end % }}}
    5555                function marshall(self,prefix,md,fid) % {{{
    56                         WriteData(fid,prefix,'object',self,'fieldname','groundedice_levelset','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     56                        WriteData(fid,prefix,'object',self,'fieldname','ocean_levelset','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    5757                        WriteData(fid,prefix,'object',self,'fieldname','ice_levelset','format','DoubleMat','mattype',1);
    5858                end % }}}
    5959                function savemodeljs(self,fid,modelname) % {{{
    6060               
    61                         writejs1Darray(fid,[modelname '.mask.groundedice_levelset'],self.groundedice_levelset);
     61                        writejs1Darray(fid,[modelname '.mask.ocean_levelset'],self.ocean_levelset);
    6262                        writejs1Darray(fid,[modelname '.mask.ice_levelset'],self.ice_levelset);
    6363
    6464                end % }}}

  • ../trunk-jpl/src/m/classes/maskpsl.py

     
    1313    #      maskpsl = maskpsl()
    1414
    1515    def __init__(self, *args):  # {{{
    16         self.groundedice_levelset = float('NaN')
     16        self.ocean_levelset = float('NaN')
    1717        self.ice_levelset = float('NaN')
    1818        self.ocean_levelset = float('NaN')
    1919        self.land_levelset = float('NaN')
    … …  
    2626
    2727    def __repr__(self):  # {{{
    2828        string = '   masks:'
    29         string = "%s\n%s" % (string, fielddisplay(self, 'groundedice_levelset', 'is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0'))
     29        string = "%s\n%s" % (string, fielddisplay(self, 'ocean_levelset', 'is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0'))
    3030        string = "%s\n%s" % (string, fielddisplay(self, 'ice_levelset', 'presence of ice if < 0, icefront position if = 0, no ice if > 0'))
    3131        string = "%s\n%s" % (string, fielddisplay(self, 'ocean_levelset', 'is the vertex on the ocean ? yes if = 1, no if = 0'))
    3232        string = "%s\n%s" % (string, fielddisplay(self, 'land_levelset', 'is the vertex on the land ? yes if = 1, no if = 0'))
    … …  
    4949    # }}}
    5050
    5151    def checkconsistency(self, md, solution, analyses):  # {{{
    52         md = checkfield(md, 'fieldname', 'mask.groundedice_levelset', 'size', [md.mesh.numberofvertices])
     52        md = checkfield(md, 'fieldname', 'mask.ocean_levelset', 'size', [md.mesh.numberofvertices])
    5353        md = checkfield(md, 'fieldname', 'mask.ice_levelset', 'size', [md.mesh.numberofvertices])
    5454        md = checkfield(md, 'fieldname', 'mask.ocean_levelset', 'size', [md.mesh.numberofvertices])
    5555        md = checkfield(md, 'fieldname', 'mask.land_levelset', 'size', [md.mesh.numberofvertices])
    … …  
    7171    # }}}
    7272
    7373    def extrude(self, md):  # {{{
    74         self.groundedice_levelset = project3d(md, 'vector', self.groundedice_levelset, 'type', 'node')
     74        self.ocean_levelset = project3d(md, 'vector', self.ocean_levelset, 'type', 'node')
    7575        self.ice_levelset = project3d(md, 'vector', self.ice_levelset, 'type', 'node')
    7676        self.ocean_levelset = project3d(md, 'vector', self.ocean_levelset, 'type', 'node')
    7777        self.land_levelset = project3d(md, 'vector', self.land_levelset, 'type', 'node')
    … …  
    8989
    9090    def marshall(self, prefix, md, fid):  # {{{
    9191        WriteData(fid, prefix, 'name', 'md.mask.type', 'data', type(md.mask).__name__, 'format', 'String')
    92         WriteData(fid, prefix, 'object', self, 'class', 'mask', 'fieldname', 'groundedice_levelset', 'format', 'DoubleMat', 'mattype', 1)
     92        WriteData(fid, prefix, 'object', self, 'class', 'mask', 'fieldname', 'ocean_levelset', 'format', 'DoubleMat', 'mattype', 1)
    9393        WriteData(fid, prefix, 'object', self, 'class', 'mask', 'fieldname', 'ice_levelset', 'format', 'DoubleMat', 'mattype', 1)
    9494        WriteData(fid, prefix, 'object', self, 'class', 'mask', 'fieldname', 'ocean_levelset', 'format', 'DoubleMat', 'mattype', 1)
    9595        WriteData(fid, prefix, 'object', self, 'class', 'mask', 'fieldname', 'land_levelset', 'format', 'DoubleMat', 'mattype', 1)
    … …  
    9696    # }}}
    9797
    9898    def savemodeljs(self, fid, modelname):  # {{{
    99         writejs1Darray(fid, [modelname, '.mask.groundedice_levelset'], self.groundedice_levelset)
     99        writejs1Darray(fid, [modelname, '.mask.ocean_levelset'], self.ocean_levelset)
    100100        writejs1Darray(fid, [modelname, '.mask.ice_levelset'], self.ice_levelset)
    101101        writejs1Darray(fid, [modelname, '.mask.ocean_levelset'], self.ocean_levelset)
    102102        writejs1Darray(fid, [modelname, '.mask.land_levelset'], self.land_levelset)

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

     
    119119
    120120        if 'StressbalanceSIAAnalysis' in analyses:
    121121            if any(self.element_equation == 1):
    122                 if np.any(np.logical_and(self.vertex_equation, md.mask.groundedice_levelset)):
     122                if np.any(np.logical_and(self.vertex_equation, md.mask.ocean_levelset)):
    123123                    print("\n !!! Warning: SIA's model is not consistent on ice shelves !!!\n")
    124124
    125125        return md

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

     
    6363                md = checkfield(md, 'fieldname', 'geometry.bed', 'NaN', 1, 'Inf', 1, 'size', [md.mesh.numberofvertices])
    6464                if np.any(self.bed - self.base > 10**-12):
    6565                    md.checkmessage('base < bed on one or more vertex')
    66                 pos = np.where(md.mask.groundedice_levelset > 0)
     66                pos = np.where(md.mask.ocean_levelset > 0)
    6767                if np.any(np.abs(self.bed[pos] - self.base[pos]) > 10**-9):
    6868                    md.checkmessage('equality base = bed on grounded ice violated')
    6969                md = checkfield(md, 'fieldname', 'geometry.bed', 'NaN', 1, 'Inf', 1, 'size', [md.mesh.numberofvertices])

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

     
    840840        md.geometry.base = project2d(md, md.geometry.base, 1)
    841841        if isinstance(md.geometry.bed, np.ndarray):
    842842            md.geometry.bed = project2d(md, md.geometry.bed, 1)
    843         md.mask.groundedice_levelset = project2d(md, md.mask.groundedice_levelset, 1)
     843        md.mask.ocean_levelset = project2d(md, md.mask.ocean_levelset, 1)
    844844        md.mask.ice_levelset = project2d(md, md.mask.ice_levelset, 1)
    845845
    846846        #OutputDefinitions

  • ../trunk-jpl/src/m/classes/stressbalance.py

     
    155155                    md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
    156156        #CHECK THAT NO rotation specified for FS Grounded ice at base
    157157        if m.strcmp(md.mesh.domaintype(), '3D') and md.flowequation.isFS:
    158             pos = np.nonzero(np.logical_and(md.mask.groundedice_levelset, md.mesh.vertexonbase))
     158            pos = np.nonzero(np.logical_and(md.mask.ocean_levelset, md.mesh.vertexonbase))
    159159            if np.any(np.logical_not(np.isnan(md.stressbalance.referential[pos, :]))):
    160160                md.checkmessage("no referential should be specified for basal vertices of grounded ice")
    161161

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

     
    1515
    1616    def __init__(self):  # {{{
    1717        self.ice_levelset = float('NaN')
    18         self.groundedice_levelset = float('NaN')
     18        self.ocean_levelset = float('NaN')
    1919
    2020    #set defaults
    2121        self.setdefaultparameters()
    … …  
    2525    def __repr__(self):  # {{{
    2626        string = "   masks:"
    2727
    28         string = "%s\n%s" % (string, fielddisplay(self, "groundedice_levelset", "is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0"))
     28        string = "%s\n%s" % (string, fielddisplay(self, "ocean_levelset", "is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0"))
    2929        string = "%s\n%s" % (string, fielddisplay(self, "ice_levelset", "presence of ice if < 0, icefront position if = 0, no ice if > 0"))
    3030        return string
    3131    #}}}
    … …  
    3232
    3333    def extrude(self, md):  # {{{
    3434        self.ice_levelset = project3d(md, 'vector', self.ice_levelset, 'type', 'node')
    35         self.groundedice_levelset = project3d(md, 'vector', self.groundedice_levelset, 'type', 'node')
     35        self.ocean_levelset = project3d(md, 'vector', self.ocean_levelset, 'type', 'node')
    3636        return self
    3737    #}}}
    3838
    … …  
    5353    # }}}
    5454
    5555    def marshall(self, prefix, md, fid):  # {{{
    56         WriteData(fid, prefix, 'object', self, 'fieldname', 'groundedice_levelset', 'format', 'DoubleMat', 'mattype', 1)
     56        WriteData(fid, prefix, 'object', self, 'fieldname', 'ocean_levelset', 'format', 'DoubleMat', 'mattype', 1)
    5757        WriteData(fid, prefix, 'object', self, 'fieldname', 'ice_levelset', 'format', 'DoubleMat', 'mattype', 1)
    5858    # }}}

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

     
    128128                        end
    129129                        if ismember('StressbalanceSIAAnalysis',analyses),
    130130                                if any(self.element_equation==1),
    131                                         if(self.vertex_equation & md.mask.groundedice_levelset<0.),
     131                                        if(self.vertex_equation & md.mask.ocean_levelset<0.),
    132132                                                disp(sprintf('\n !!! Warning: SIA''s model is not consistent on ice shelves !!!\n'));
    133133                                        end
    134134                                end

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

     
    362362                                md.geometry.bed=project2d(md,md.geometry.bed,1);
    363363                        end
    364364
    365                         if ~isnan(md.mask.groundedice_levelset),
    366                                 md.mask.groundedice_levelset=project2d(md,md.mask.groundedice_levelset,1);
     365                        if ~isnan(md.mask.ocean_levelset),
     366                                md.mask.ocean_levelset=project2d(md,md.mask.ocean_levelset,1);
    367367                        end
    368368                        if ~isnan(md.mask.ice_levelset),
    369369                                md.mask.ice_levelset=project2d(md,md.mask.ice_levelset,1);

  • ../trunk-jpl/src/m/contrib/morlighem/dassflow/exportgmsh.m

     
    1 function exportgmsh(mesh,groundedice_levelset,filename),
     1function exportgmsh(mesh,ocean_levelset,filename),
    22%EXPORTGMSH - export mesh to gmsh format
    33%
    44%   http://www.geuz.org/gmsh/doc/texinfo/#MSH-ASCII-file-format
    55%
    66%   Usage:
    7 %      exportgmsh(mesh,groundedice_levelset,filename)
     7%      exportgmsh(mesh,ocean_levelset,filename)
    88%
    99%   Example:
    10 %      exportgmsh(md.mesh,md.mask.groundedice_levelset,'temp.msh')
     10%      exportgmsh(md.mesh,md.mask.ocean_levelset,'temp.msh')
    1111
    1212fid=fopen(filename,'w');
    1313
    … …  
    3030tria    = 2;
    3131
    3232%Create flags
    33 grounded = sum(groundedice_levelset(mesh.segments(:,1:2))>0,2);
     33grounded = sum(ocean_levelset(mesh.segments(:,1:2))>0,2);
    3434A = zeros(nbs,2);
    3535pos = find(mesh.segmentmarkers==4);
    3636A(pos,:)=repmat([1,4],[numel(pos) 1]);

  • ../trunk-jpl/src/m/contrib/larour/ecco/MeltingGroundingLines.m

     
    66%
    77
    88%get nodes on ice sheet and on ice shelf
    9 pos_shelf=find(md.mask.groundedice_levelset<0.);
     9pos_shelf=find(md.mask.ocean_levelset<0.);
    1010pos_GL=intersect(unique(md.mesh.elements(find(md.mask.elementongroundedice),:)),unique(md.mesh.elements(find(md.mask.elementonfloatingice),:)));
    1111
    1212for i=1:length(pos_shelf)

  • ../trunk-jpl/src/m/contrib/tsantos/mismip/gl_position.m

     
    22
    33                %initialization of some variables
    44                if isfield(md.results,'TransientSolution')
    5                         data            = md.results.TransientSolution(step).MaskGroundediceLevelset;
     5                        data            = md.results.TransientSolution(step).MaskOceanLevelset;
    66                        if isfield(md.results.TransientSolution,'MeshElements')
    77                                index   = md.results.TransientSolution(step).MeshElements;
    88                                x               = md.results.TransientSolution(step).MeshX;
    … …  
    1313                                y               = md.mesh.y;
    1414                        end
    1515                else
    16                         data    = md.mask.groundedice_levelset;
     16                        data    = md.mask.ocean_levelset;
    1717                        index   = md.mesh.elements;
    1818                        x               = md.mesh.x;
    1919                        y               = md.mesh.y;

  • ../trunk-jpl/src/m/contrib/tsantos/mismip/gl_position_static.m

     
    22
    33                %initialization of some variables
    44                if isfield(md.results,'TransientSolution') & false
    5                         data            = md.results.TransientSolution(step).MaskGroundediceLevelset;
     5                        data            = md.results.TransientSolution(step).MaskOceanLevelset;
    66                        if isfield(md.results.TransientSolution,'MeshElements')
    77                                index   = md.results.TransientSolution(step).MeshElements;
    88                                x               = md.results.TransientSolution(step).MeshX;
    … …  
    1313                                y               = md.mesh.y;
    1414                        end
    1515                else
    16                         data    = md.mask.groundedice_levelset;
     16                        data    = md.mask.ocean_levelset;
    1717                        index   = md.mesh.elements;
    1818                        x               = md.mesh.x;
    1919                        y               = md.mesh.y;

  • ../trunk-jpl/src/m/contrib/tsantos/remesh.m

     
    6262NewModel.geometry.base                                  = md.results.TransientSolution(time_step).Base;
    6363NewModel.geometry.bed                                   = md.results.TransientSolution(time_step).Bed;%md.geometry.bed; %use from parameterize
    6464NewModel.geometry.thickness                     = md.results.TransientSolution(time_step).Thickness;
    65 NewModel.mask.groundedice_levelset  = md.results.TransientSolution(time_step).MaskGroundediceLevelset;
     65NewModel.mask.ocean_levelset  = md.results.TransientSolution(time_step).MaskOceanLevelset;
    6666   
    6767%copy other data
    6868NewModel.miscellaneous          = md.miscellaneous;

  • ../trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py

     
    3131    else:
    3232        #Guess where the ice front is
    3333        vertexonfloatingice = np.zeros((md.mesh.numberofvertices))
    34         pos = np.nonzero(np.sum(md.mask.groundedice_levelset[md.mesh.elements - 1] < 0., axis=1) > 0.)[0]
     34        pos = np.nonzero(np.sum(md.mask.ocean_levelset[md.mesh.elements - 1] < 0., axis=1) > 0.)[0]
    3535        vertexonfloatingice[md.mesh.elements[pos].astype(int) - 1] = 1.
    3636        vertexonicefront = np.logical_and(np.reshape(md.mesh.vertexonboundary, (-1, )), vertexonfloatingice > 0.)
    3737
    … …  
    102102            md.thermal.spctemperature[pos] = md.initialization.temperature[pos]  #impose observed temperature on surface
    103103        if not isinstance(md.basalforcings.geothermalflux, np.ndarray) or not np.size(md.basalforcings.geothermalflux, axis=0) == md.mesh.numberofvertices:
    104104            md.basalforcings.geothermalflux = np.zeros((md.mesh.numberofvertices))
    105             md.basalforcings.geothermalflux[np.nonzero(md.mask.groundedice_levelset > 0.)] = 50. * 10.**- 3  #50mW / m2
     105            md.basalforcings.geothermalflux[np.nonzero(md.mask.ocean_levelset > 0.)] = 50. * 10.**- 3  #50mW / m2
    106106    else:
    107107        print("      no thermal boundary conditions created: no observed temperature found")
    108108

  • ../trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m

     
    3232        vertexonicefront=double(md.mesh.vertexonboundary & incontour);
    3333else
    3434        %Guess where the ice front is
    35         pos=find(sum(md.mask.groundedice_levelset(md.mesh.elements)<0.,2) >0.);
     35        pos=find(sum(md.mask.ocean_levelset(md.mesh.elements)<0.,2) >0.);
    3636        vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
    3737        vertexonfloatingice(md.mesh.elements(pos,:))=1.;
    3838        vertexonicefront=double(md.mesh.vertexonboundary & vertexonfloatingice);
    … …  
    101101        end
    102102        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
    103103                md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    104                 md.basalforcings.geothermalflux(find(md.mask.groundedice_levelset>0.))=50.*10.^-3; %50mW/m2
     104                md.basalforcings.geothermalflux(find(md.mask.ocean_levelset>0.))=50.*10.^-3; %50mW/m2
    105105        end
    106106else
    107107        disp('      no thermal boundary conditions created: no observed temperature found');

  • ../trunk-jpl/src/m/mesh/modelmerge2d.m

     
    9494
    9595                %now we can go through classes and transfer.
    9696                md=transfer_fields(md,md1,md2,'geometry',{'thickness','surface','bed','base'});
    97                 md=transfer_fields(md,md1,md2,'mask',{'groundedice_levelset','ice_levelset','ocean_levelset','land_levelset','glacier_levelset'});
     97                md=transfer_fields(md,md1,md2,'mask',{'ocean_levelset','ice_levelset','ocean_levelset','land_levelset','glacier_levelset'});
    9898                md=transfer_fields(md,md1,md2,'smb',{'mass_balance'});
    9999                if strcmpi(class(md1.basalforcings),'linearbasalforcings'),
    100100                        md=transfer_fields(md,md1,md2,'basalforcings',{'groundedice_melting_rate','geothermalflux'});

  • ../trunk-jpl/src/m/mesh/TwoDToThreeD.m

     
    3737                md.mask=mask;
    3838        else
    3939                md.mask.ice_levelset=mask.ice_levelset;
    40                 md.mask.groundedice_levelset=mask.groundedice_levelset;
     40                md.mask.ocean_levelset=mask.ocean_levelset;
    4141        end

  • ../trunk-jpl/src/m/regional/BasinConstrainShelf.m

     
    6565md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    6666
    6767%iceshelves: any vertex on floating ice is spc'd
    68 pos=find(md.mask.groundedice_levelset<0.);
     68pos=find(md.mask.ocean_levelset<0.);
    6969md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
    7070md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    7171

  • ../trunk-jpl/src/m/miscellaneous/diagnostics.m

     
    3434
    3535        %grounding line :
    3636        if getfieldvalue(options,'gl',0),
    37                 contours=contourlevelzero(md,md.mask.groundedice_levelset,0);
     37                contours=contourlevelzero(md,md.mask.ocean_levelset,0);
    3838                expwrite(contours,[path '/groundingline.exp']);
    3939                exp2shp([path '/groundingline.shp'],[path '/groundingline.exp']);
    4040        end

  • ../trunk-jpl/src/m/miscellaneous/transientrestart.m

     
    5454end
    5555
    5656%Update mask
    57 if isfield(results,'MaskGroundediceLevelset'),
    58         md.mask.groundedice_levelset = results.MaskGroundediceLevelset;
     57if isfield(results,'MaskOceanLevelset'),
     58        md.mask.ocean_levelset = results.MaskOceanLevelset;
    5959end
    6060if isfield(results,'MaskIceLevelset'),
    6161        md.mask.ice_levelset = results.MaskIceLevelset;

  • ../trunk-jpl/src/m/parameterization/sethydrostaticmask.py

     
    33
    44def setmask(md):
    55    """
    6     SETHYDROSTATICMASK - establish groundedice_levelset field
     6    SETHYDROSTATICMASK - establish ocean_levelset field
    77
    88   Determines grounded and floating ice position based on
    99   md.geometry.bed and md.geometry.thickness
    … …  
    1919        raise IOError("hydrostaticmask error message: fields in md.geometry do not have the right size.")
    2020
    2121    # grounded ice level set
    22     md.mask.groundedice_levelset = md.geometry.thickness + md.geometry.bed * md.materials.rho_water / md.materials.rho_ice
     22    md.mask.ocean_levelset = md.geometry.thickness + md.geometry.bed * md.materials.rho_water / md.materials.rho_ice
    2323
    2424    #Check consistency of geometry
    25     if any(md.geometry.base[np.nonzero(md.mask.groundedice_levelset > 0.)] != md.geometry.bed[np.nonzero(md.mask.groundedice_levelset > 0.)]):
     25    if any(md.geometry.base[np.nonzero(md.mask.ocean_levelset > 0.)] != md.geometry.bed[np.nonzero(md.mask.ocean_levelset > 0.)]):
    2626        print("WARNING: md.geometry.bed and md.geometry.base not equal on grounded ice")
    2727
    28     if any(md.geometry.base[np.nonzero(md.mask.groundedice_levelset <= 0.)] < md.geometry.bed[np.nonzero(md.mask.groundedice_levelset <= 0.)]):
     28    if any(md.geometry.base[np.nonzero(md.mask.ocean_levelset <= 0.)] < md.geometry.bed[np.nonzero(md.mask.ocean_levelset <= 0.)]):
    2929        print("WARNING: md.geometry.base < md.geometry.bed on floating ice")
    3030
    3131    return md

  • ../trunk-jpl/src/m/parameterization/setmask.py

     
    5555    #}}}
    5656
    5757    #level sets
    58     md.mask.groundedice_levelset = -1. * np.ones(md.mesh.numberofvertices)
    59     md.mask.groundedice_levelset[md.mesh.elements[np.nonzero(elementongroundedice), :] - 1] = 1.
     58    md.mask.ocean_levelset = -1. * np.ones(md.mesh.numberofvertices)
     59    md.mask.ocean_levelset[md.mesh.elements[np.nonzero(elementongroundedice), :] - 1] = 1.
    6060
    6161    if(len(args)):
    6262        md.mask.ice_levelset = 1. * np.ones(md.mesh.numberofvertices)

  • ../trunk-jpl/src/m/parameterization/sethydrostaticmask.m

     
    11function md=sethydrostaticmask(md)
    2 %SETHYDROSTATICMASK - establish groundedice_levelset field
     2%SETHYDROSTATICMASK - establish ocean_levelset field
    33%
    44%   Determines grounded and floating ice position based on
    55%   md.geometry.bed and md.geometry.thickness
    … …  
    1515end
    1616
    1717%grounded ice level set
    18 md.mask.groundedice_levelset=md.geometry.thickness+md.geometry.bed*md.materials.rho_water/md.materials.rho_ice;
     18md.mask.ocean_levelset=md.geometry.thickness+md.geometry.bed*md.materials.rho_water/md.materials.rho_ice;
    1919
    2020%Check consistency of geometry
    21 pos=find(md.mask.groundedice_levelset>0);
     21pos=find(md.mask.ocean_levelset>0);
    2222if(any(md.geometry.base(pos)~=md.geometry.bed(pos))),
    2323        disp('WARNING: md.geometry.bed and md.geometry.base not equal on grounded ice');
    2424end
    2525
    26 pos=find(md.mask.groundedice_levelset<=0);
     26pos=find(md.mask.ocean_levelset<=0);
    2727if(any(md.geometry.base(pos)<md.geometry.bed(pos))),
    2828        disp('WARNING: md.geometry.base < md.geometry.bed on floating ice');
    2929end

  • ../trunk-jpl/src/m/parameterization/setmask.m

     
    5252%}}}
    5353
    5454%level sets
    55 md.mask.groundedice_levelset=vertexongroundedice;
    56 md.mask.groundedice_levelset(find(vertexongroundedice==0.))=-1.;
     55md.mask.ocean_levelset=vertexongroundedice;
     56md.mask.ocean_levelset(find(vertexongroundedice==0.))=-1.;
    5757
    5858if(nargin>3)
    5959        if(varargin(1)=='icedomain')

  • ../trunk-jpl/src/m/parameterization/killberg.m

     
    22function ice_levelset = killberg(md)
    33%KILLBERG - kill ice berg
    44%
    5 %   check md.mask.ice_levelset and md.mask.groundedice_levelset and
     5%   check md.mask.ice_levelset and md.mask.ocean_levelset and
    66%   remove icebergs from md.mask.ice_levelset. This function is adapted
    77%   from src/c/modules/KillIcebergsx/KillIcebergsx.cpp
    88%
    … …  
    2424
    2525%do not go through elements that are grounded, mark flag as 1 (done)
    2626%and initialize mask as 1 for all vertices of these elements
    27 isgrounded = max(md.mask.groundedice_levelset(md.mesh.elements),[],2)>0;
     27isgrounded = max(md.mask.ocean_levelset(md.mesh.elements),[],2)>0;
    2828pos = find(isgrounded);
    2929element_flag(pos) = 1;
    3030mask(md.mesh.elements(pos,:)) = 1;

  • ../trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

     
    626626                case LoadingforceXEnum : return "LoadingforceX";
    627627                case LoadingforceYEnum : return "LoadingforceY";
    628628                case LoadingforceZEnum : return "LoadingforceZ";
    629                 case MaskGroundediceLevelsetEnum : return "MaskGroundediceLevelset";
     629                case MaskOceanLevelsetEnum : return "MaskOceanLevelset";
    630630                case MaskIceLevelsetEnum : return "MaskIceLevelset";
    631631                case MaskLandLevelsetEnum : return "MaskLandLevelset";
    632                 case MaskOceanLevelsetEnum : return "MaskOceanLevelset";
    633632                case MasstransportSpcthicknessEnum : return "MasstransportSpcthickness";
    634633                case MaterialsRheologyBEnum : return "MaterialsRheologyB";
    635634                case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar";

  • ../trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

     
    641641              else if (strcmp(name,"LoadingforceX")==0) return LoadingforceXEnum;
    642642              else if (strcmp(name,"LoadingforceY")==0) return LoadingforceYEnum;
    643643              else if (strcmp(name,"LoadingforceZ")==0) return LoadingforceZEnum;
    644               else if (strcmp(name,"MaskGroundediceLevelset")==0) return MaskGroundediceLevelsetEnum;
     644              else if (strcmp(name,"MaskOceanLevelset")==0) return MaskOceanLevelsetEnum;
    645645              else if (strcmp(name,"MaskIceLevelset")==0) return MaskIceLevelsetEnum;
    646646              else if (strcmp(name,"MaskLandLevelset")==0) return MaskLandLevelsetEnum;
    647               else if (strcmp(name,"MaskOceanLevelset")==0) return MaskOceanLevelsetEnum;
    648647              else if (strcmp(name,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum;
    649648              else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum;
    650649              else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum;
    … …  
    751750              else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
    752751              else if (strcmp(name,"SmbMassBalanceClimate")==0) return SmbMassBalanceClimateEnum;
    753752              else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
     753              else if (strcmp(name,"SmbMassBalanceSubstep")==0) return SmbMassBalanceSubstepEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"SmbMassBalanceSubstep")==0) return SmbMassBalanceSubstepEnum;
    758               else if (strcmp(name,"SmbMassBalanceTransient")==0) return SmbMassBalanceTransientEnum;
     757              if (strcmp(name,"SmbMassBalanceTransient")==0) return SmbMassBalanceTransientEnum;
    759758              else if (strcmp(name,"SmbMeanLHF")==0) return SmbMeanLHFEnum;
    760759              else if (strcmp(name,"SmbMeanSHF")==0) return SmbMeanSHFEnum;
    761760              else if (strcmp(name,"SmbMeanULW")==0) return SmbMeanULWEnum;
    … …  
    874873              else if (strcmp(name,"Outputdefinition12")==0) return Outputdefinition12Enum;
    875874              else if (strcmp(name,"Outputdefinition13")==0) return Outputdefinition13Enum;
    876875              else if (strcmp(name,"Outputdefinition14")==0) return Outputdefinition14Enum;
     876              else if (strcmp(name,"Outputdefinition15")==0) return Outputdefinition15Enum;
    877877         else stage=8;
    878878   }
    879879   if(stage==8){
    880               if (strcmp(name,"Outputdefinition15")==0) return Outputdefinition15Enum;
    881               else if (strcmp(name,"Outputdefinition16")==0) return Outputdefinition16Enum;
     880              if (strcmp(name,"Outputdefinition16")==0) return Outputdefinition16Enum;
    882881              else if (strcmp(name,"Outputdefinition17")==0) return Outputdefinition17Enum;
    883882              else if (strcmp(name,"Outputdefinition18")==0) return Outputdefinition18Enum;
    884883              else if (strcmp(name,"Outputdefinition19")==0) return Outputdefinition19Enum;
    … …  
    997996              else if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum;
    998997              else if (strcmp(name,"BeckmannGoosseFloatingMeltRate")==0) return BeckmannGoosseFloatingMeltRateEnum;
    999998              else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum;
     999              else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    10001000         else stage=9;
    10011001   }
    10021002   if(stage==9){
    1003               if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    1004               else if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
     1003              if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
    10051004              else if (strcmp(name,"BoolInput2")==0) return BoolInput2Enum;
    10061005              else if (strcmp(name,"IntInput2")==0) return IntInput2Enum;
    10071006              else if (strcmp(name,"BoolParam")==0) return BoolParamEnum;
    … …  
    11201119              else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum;
    11211120              else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum;
    11221121              else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum;
     1122              else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
    11231123         else stage=10;
    11241124   }
    11251125   if(stage==10){
    1126               if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
    1127               else if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum;
     1126              if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum;
    11281127              else if (strcmp(name,"IcefrontMassFlux")==0) return IcefrontMassFluxEnum;
    11291128              else if (strcmp(name,"IcefrontMassFluxLevelset")==0) return IcefrontMassFluxLevelsetEnum;
    11301129              else if (strcmp(name,"Incremental")==0) return IncrementalEnum;
    … …  
    12431242              else if (strcmp(name,"Penta")==0) return PentaEnum;
    12441243              else if (strcmp(name,"PentaInput")==0) return PentaInputEnum;
    12451244              else if (strcmp(name,"Profiler")==0) return ProfilerEnum;
     1245              else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;
    12461246         else stage=11;
    12471247   }
    12481248   if(stage==11){
    1249               if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;
    1250               else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum;
     1249              if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum;
    12511250              else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
    12521251              else if (strcmp(name,"Regionaloutput")==0) return RegionaloutputEnum;
    12531252              else if (strcmp(name,"Regular")==0) return RegularEnum;

  • ../trunk-jpl/src/c/shared/Enum/Enum.vim

     
    624624syn keyword cConstant LoadingforceXEnum
    625625syn keyword cConstant LoadingforceYEnum
    626626syn keyword cConstant LoadingforceZEnum
    627 syn keyword cConstant MaskGroundediceLevelsetEnum
     627syn keyword cConstant MaskOceanLevelsetEnum
    628628syn keyword cConstant MaskIceLevelsetEnum
    629629syn keyword cConstant MaskLandLevelsetEnum
    630 syn keyword cConstant MaskOceanLevelsetEnum
    631630syn keyword cConstant MasstransportSpcthicknessEnum
    632631syn keyword cConstant MaterialsRheologyBEnum
    633632syn keyword cConstant MaterialsRheologyBbarEnum

  • ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

     
    621621        LoadingforceXEnum,
    622622        LoadingforceYEnum,
    623623        LoadingforceZEnum,
    624         MaskGroundediceLevelsetEnum,
     624        MaskOceanLevelsetEnum,
    625625        MaskIceLevelsetEnum,
    626626        MaskLandLevelsetEnum,
    627         MaskOceanLevelsetEnum,
    628627        MasstransportSpcthicknessEnum,
    629628        MaterialsRheologyBEnum,
    630629        MaterialsRheologyBbarEnum,

  • ../trunk-jpl/src/c/modules/FloatingiceMeltingRatePicox/FloatingiceMeltingRatePicox.cpp

     
    4545        femmodel->parameters->FindParam(&maxbox,BasalforcingsPicoMaxboxcountEnum);
    4646        IssmDouble* dmax_basin_cpu=xNew<IssmDouble>(num_basins);
    4747
    48         InputDuplicatex(femmodel,MaskGroundediceLevelsetEnum,DistanceToGroundinglineEnum);
    49         femmodel->DistanceToFieldValue(MaskGroundediceLevelsetEnum,0.,DistanceToGroundinglineEnum);
     48        InputDuplicatex(femmodel,MaskOceanLevelsetEnum,DistanceToGroundinglineEnum);
     49        femmodel->DistanceToFieldValue(MaskOceanLevelsetEnum,0.,DistanceToGroundinglineEnum);
    5050
    5151        InputDuplicatex(femmodel,MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
    5252        femmodel->DistanceToFieldValue(MaskIceLevelsetEnum,0.,DistanceToCalvingfrontEnum);

  • ../trunk-jpl/src/c/modules/GroundinglineMigrationx/GroundinglineMigrationx.cpp

     
    136136        vec_phi=new Vector<IssmDouble>(vertices->NumberOfVertices());
    137137        for(i=0;i<elements->Size();i++){
    138138                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    139                 element->GetVectorFromInputs(vec_phi,MaskGroundediceLevelsetEnum,VertexPIdEnum);
     139                element->GetVectorFromInputs(vec_phi,MaskOceanLevelsetEnum,VertexPIdEnum);
    140140        }
    141141        vec_phi->Assemble();
    142142        phi=vec_phi->ToMPISerial();

  • ../trunk-jpl/src/c/cores/transient_core.cpp

     
    196196                        if(VerboseSolution()) _printf0_("   computing new grounding line position\n");
    197197                        GroundinglineMigrationx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    198198
    199                         femmodel->parameters->SetParam(MaskGroundediceLevelsetEnum,InputToExtrudeEnum);
     199                        femmodel->parameters->SetParam(MaskOceanLevelsetEnum,InputToExtrudeEnum);
    200200                        extrudefrombase_core(femmodel);
    201201                        femmodel->parameters->SetParam(BaseEnum,InputToExtrudeEnum);
    202202                        extrudefrombase_core(femmodel);
    … …  
    207207                        femmodel->profiler->Stop(GROUNDINGLINECORE);
    208208
    209209                        if(save_results){
    210                                 int outputs[3] = {SurfaceEnum,BaseEnum,MaskGroundediceLevelsetEnum};
     210                                int outputs[3] = {SurfaceEnum,BaseEnum,MaskOceanLevelsetEnum};
    211211                                femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],3);
    212212                        }
    213213                }
    … …  
    231231                if(VerboseSolution()) _printf0_("   computing requested outputs\n");
    232232                femmodel->RequestedOutputsx(&femmodel->results,requested_outputs,numoutputs,save_results);
    233233                if(isgroundingline && (groundingline_migration==AggressiveMigrationEnum || groundingline_migration==ContactEnum)){
    234                         int outputs[1] = {MaskGroundediceLevelsetEnum};
     234                        int outputs[1] = {MaskOceanLevelsetEnum};
    235235                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],1,save_results);
    236236                }
    237237

  • ../trunk-jpl/src/c/classes/Loads/Riftfront.cpp

     
    8585        this->fill = IoRiftfillToEnum(reCast<int,IssmDouble>(*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+7)));
    8686        this->friction=*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+8);
    8787        this->fractionincrement=*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+10);
    88         this->shelf=reCast<bool,IssmDouble>(iomodel->Data("md.mask.groundedice_levelset")[node1-1]<0.);
     88        this->shelf=reCast<bool,IssmDouble>(iomodel->Data("md.mask.ocean_levelset")[node1-1]<0.);
    8989
    9090        //parameters and hooked fields: we still can't point to them, they may not even exist. Configure will handle this.
    9191        this->parameters=NULL;

  • ../trunk-jpl/src/c/classes/FemModel.h

     
    194194                void GetMesh(int** elementslist, IssmDouble** x, IssmDouble** y, int* numberofvertices, int* numberofelements);
    195195                void SetMesh(int** elementslist, IssmDouble** x, IssmDouble** y, int* numberofvertices, int* numberofelements);
    196196                void GetMeshOnPartition(Vertices* femmodel_vertices,Elements* femmodel_elements,IssmDouble** px, IssmDouble** py, IssmDouble** pz, int** pelementslist,int** psidtoindex);
    197                 void GetGroundediceLevelSet(IssmDouble** pmasklevelset);
    198197                void CreateElements(int newnumberofelements,int elementswidth,int* newelementslist,bool* my_elements,Elements* elements);
    199198                void CreateMaterials(int newnumberofelements,bool* my_elements,Materials* materials);
    200199                void CreateConstraints(Vertices* newfemmodel_vertices,int analysis_enum,Constraints* newfemmodel_constraints);

  • ../trunk-jpl/src/c/classes/FemModel.cpp

     
    33493349                }
    33503350
    33513351                /*Update inputs*/
    3352                 element->AddInput2(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
     3352                element->AddInput2(MaskOceanLevelsetEnum,&phi[0],P1Enum);
    33533353                element->AddInput2(ThicknessEnum,&h[0],P1Enum);
    33543354                element->AddInput2(BaseEnum,&b[0],P1Enum);
    33553355        }
    … …  
    36703670   return;
    36713671}
    36723672/*}}}*/
    3673 void FemModel::GetGroundediceLevelSet(IssmDouble **pmasklevelset){/*{{{*/
    3674 
    3675         int elementswidth               = this->GetElementsWidth();//just 2D mesh, tria elements
    3676         int numberofvertices = this->vertices->NumberOfVertices();
    3677 
    3678         IssmDouble* elementlevelset=xNew<IssmDouble>(elementswidth);
    3679         int* elem_vertices=xNew<int>(elementswidth);
    3680         Vector<IssmDouble>* vmasklevelset=new Vector<IssmDouble>(numberofvertices);
    3681 
    3682         for(int i=0;i<this->elements->Size();i++){
    3683                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    3684                 element->GetInputListOnVertices(elementlevelset,MaskGroundediceLevelsetEnum);
    3685                 element->GetVerticesSidList(elem_vertices);
    3686                 vmasklevelset->SetValue(elem_vertices[0],elementlevelset[0],INS_VAL);
    3687       vmasklevelset->SetValue(elem_vertices[1],elementlevelset[1],INS_VAL);
    3688       vmasklevelset->SetValue(elem_vertices[2],elementlevelset[2],INS_VAL);
    3689         }
    3690 
    3691    /*Assemble*/
    3692         vmasklevelset->Assemble();
    3693 
    3694         /*Serialize and set output*/
    3695         (*pmasklevelset)=vmasklevelset->ToMPISerial();
    3696 
    3697         /*Cleanup*/
    3698         xDelete<IssmDouble>(elementlevelset);
    3699         xDelete<int>(elem_vertices);
    3700         delete vmasklevelset;
    3701 
    3702 }
    3703 /*}}}*/
    37043673void FemModel::CreateElements(int newnumberofelements,int elementswidth,int* newelementslist,bool* my_elements,Elements* elements){/*{{{*/
    37053674
    37063675        /*newlementslist is in Matlab indexing*/
    … …  
    43654334
    43664335   for(int i=0;i<this->elements->Size();i++){
    43674336      Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    4368       element->GetInputListOnVertices(elementlevelset,MaskGroundediceLevelsetEnum);
     4337      element->GetInputListOnVertices(elementlevelset,MaskOceanLevelsetEnum);
    43694338      int sid = element->Sid();
    43704339      vmasklevelset->SetValue(sid,(elementlevelset[0]+elementlevelset[1]+elementlevelset[2])/3.,INS_VAL);
    43714340   }
    … …  
    44304399
    44314400        /*Here, "zero level set" means grounding line or ice front, depending on the level set type*/
    44324401        /*pzerolevelset_points are the element center points with zero level set. X and Y coords*/
    4433         if(levelset_type!=MaskGroundediceLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
     4402        if(levelset_type!=MaskOceanLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
    44344403                _error_("level set type not implemented yet!");
    44354404        }
    44364405
    … …  
    54175386                /*Fill hmaxvertices*/
    54185387                if(this->amrbamg->thicknesserror_threshold>0)   this->GethmaxVerticesFromEstimators(hmaxvertices_serial,ThicknessErrorEstimatorEnum);
    54195388                if(this->amrbamg->deviatoricerror_threshold>0)  this->GethmaxVerticesFromEstimators(hmaxvertices_serial,DeviatoricStressErrorEstimatorEnum);
    5420                 if(this->amrbamg->groundingline_distance>0)             this->GethmaxVerticesFromZeroLevelSetDistance(hmaxvertices_serial,MaskGroundediceLevelsetEnum);
     5389                if(this->amrbamg->groundingline_distance>0)             this->GethmaxVerticesFromZeroLevelSetDistance(hmaxvertices_serial,MaskOceanLevelsetEnum);
    54215390                if(this->amrbamg->icefront_distance>0)                          this->GethmaxVerticesFromZeroLevelSetDistance(hmaxvertices_serial,MaskIceLevelsetEnum);
    54225391        }
    54235392
    … …  
    55295498        int sid,numberofpoints;
    55305499
    55315500        switch(levelset_type){
    5532                 case MaskGroundediceLevelsetEnum:
     5501                case MaskOceanLevelsetEnum:
    55335502                        threshold       = this->amrbamg->groundingline_distance;
    55345503                        resolution      = this->amrbamg->groundingline_resolution;
    55355504                        break;
    … …  
    56915660
    56925661        /*Here, "zero level set" means grounding line or ice front, depending on the level set type*/
    56935662        /*pverticedistance is the minimal vertice distance to the grounding line or ice front*/
    5694         if(levelset_type!=MaskGroundediceLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
     5663        if(levelset_type!=MaskOceanLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
    56955664                _error_("level set type not implemented yet!");
    56965665        }
    56975666
    … …  
    57535722        int newnumberofelements         = -1;
    57545723
    57555724        /*Get fields, if requested*/
    5756         if(this->amr->groundingline_distance>0)         this->GetElementDistanceToZeroLevelSet(&gl_distance,MaskGroundediceLevelsetEnum);
     5725        if(this->amr->groundingline_distance>0)         this->GetElementDistanceToZeroLevelSet(&gl_distance,MaskOceanLevelsetEnum);
    57575726   if(this->amr->icefront_distance>0)                           this->GetElementDistanceToZeroLevelSet(&if_distance,MaskIceLevelsetEnum);
    57585727   if(this->amr->thicknesserror_threshold>0)            this->ThicknessZZErrorEstimator(&thicknesserror);
    57595728        if(this->amr->deviatoricerror_threshold>0)      this->ZZErrorEstimator(&deviatoricerror);
    … …  
    58555824
    58565825        /*Here, "zero level set" means grounding line or ice front, depending on the level set type*/
    58575826        /*pverticedistance is the minimal vertice distance to the grounding line or ice front*/
    5858         if(levelset_type!=MaskGroundediceLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
     5827        if(levelset_type!=MaskOceanLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
    58595828                _error_("level set type not implemented yet!");
    58605829        }
    58615830

  • ../trunk-jpl/src/c/classes/Elements/Penta.cpp

     
    286286        /*Retrieve all inputs and parameters we will need*/
    287287        Input2* vx_input = this->GetInput2(VxAverageEnum); _assert_(vx_input);
    288288        Input2* vy_input = this->GetInput2(VyAverageEnum); _assert_(vy_input);
    289         Input2* gr_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     289        Input2* gr_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    290290        Input2* bs_input = this->GetInput2(BaseEnum);                    _assert_(bs_input);
    291291        Input2* B_input  = this->GetInput2(MaterialsRheologyBbarEnum);   _assert_(B_input);
    292292        Input2* n_input  = this->GetInput2(MaterialsRheologyNEnum);   _assert_(n_input);
    … …  
    12461246        Element::GetInputListOnVertices(&bed[0],BedEnum);
    12471247        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
    12481248        Element::GetInputListOnVertices(&pressure[0],PressureEnum);
    1249         Element::GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     1249        Element::GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
    12501250        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
    12511251        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
    12521252        IssmDouble gravity   = FindParam(ConstantsGEnum);
    … …  
    13851385        IssmDouble         f1,f2;
    13861386
    13871387        /*Recover parameters and values*/
    1388         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1388        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    13891389
    13901390        /*Be sure that values are not zero*/
    13911391        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    14391439        IssmDouble         xyz_bis[NUMVERTICES2D][3];
    14401440
    14411441        /*Recover parameters and values*/
    1442         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1442        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    14431443
    14441444        /*Be sure that values are not zero*/
    14451445        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    20682068        /*Make sure there is a grounding line here*/
    20692069        if(!IsOnBase()) return 0;
    20702070        if(!IsIceInElement()) return 0;
    2071         if(!IsZeroLevelset(MaskGroundediceLevelsetEnum)) return 0;
     2071        if(!IsZeroLevelset(MaskOceanLevelsetEnum)) return 0;
    20722072
    20732073        /*Scaled not implemented yet...*/
    20742074        _assert_(!scaled);
    … …  
    20832083        this->GetVerticesCoordinates(&xyz_list);
    20842084
    20852085        /*Recover parameters and values*/
    2086         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     2086        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    20872087
    20882088        /*Be sure that values are not zero*/
    20892089        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    31873187        density=rho_ice/rho_water;
    31883188        Element::GetInputListOnVertices(&h[0],ThicknessEnum);
    31893189        Element::GetInputListOnVertices(&r[0],BedEnum);
    3190         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     3190        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    31913191
    31923192        /*go through vertices, and figure out which ones are on the ice sheet, and want to unground: */
    31933193        for(int i=0;i<NUMVERTICES;i++){
    … …  
    32813281        /*Get inputs*/
    32823282        Input2* slopex_input=this->GetInput2(BedSlopeXEnum); _assert_(slopex_input);
    32833283        Input2* slopey_input=this->GetInput2(BedSlopeYEnum); _assert_(slopey_input);
    3284         Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     3284        Input2* groundedicelevelset_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedicelevelset_input);
    32853285
    32863286        /*Loop over basal nodes and update their CS*/
    32873287        GaussPenta* gauss = new GaussPenta();
    … …  
    41734173        /*Get material parameters :*/
    41744174        rho_ice=FindParam(MaterialsRhoIceEnum);
    41754175        Input2* floatingmelt_input = this->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    4176         Input2* gllevelset_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4176        Input2* gllevelset_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    41774177        Input2* scalefactor_input = NULL;
    41784178        if(scaled==true){
    41794179                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    … …  
    42184218        /*Get material parameters :*/
    42194219        rho_ice=FindParam(MaterialsRhoIceEnum);
    42204220        Input2* groundedmelt_input = this->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    4221         Input2* gllevelset_input   = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4221        Input2* gllevelset_input   = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    42224222        Input2* scalefactor_input  = NULL;
    42234223        if(scaled==true){
    42244224                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);

  • ../trunk-jpl/src/c/classes/Elements/Seg.cpp

     
    263263        IssmDouble        gl[NUMVERTICES];
    264264
    265265        /*Recover parameters and values*/
    266         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     266        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    267267
    268268        /*Be sure that values are not zero*/
    269269        if(gl[0]==0.) gl[0]=gl[0]+epsilon;

  • ../trunk-jpl/src/c/classes/Elements/Tetra.cpp

     
    696696        /*Get inputs*/
    697697        Input2* slopex_input=this->GetInput2(BedSlopeXEnum); _assert_(slopex_input);
    698698        Input2* slopey_input=this->GetInput2(BedSlopeYEnum); _assert_(slopey_input);
    699         Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     699        Input2* groundedicelevelset_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedicelevelset_input);
    700700        vertexonbase = xNew<IssmDouble>(numnodes);
    701701        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    702702

  • ../trunk-jpl/src/c/classes/Elements/Element.cpp

     
    19851985        int  migration_style;
    19861986        parameters->FindParam(&migration_style,GroundinglineMigrationEnum);
    19871987
    1988         Input2* input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(input);
     1988        Input2* input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(input);
    19891989
    19901990        if(migration_style==SubelementMigrationEnum){ //Floating if all nodes are floating
    19911991                if(input->GetInputMax() <= 0.) shelf=true;
    … …  
    20052005}/*}}}*/
    20062006bool       Element::IsGrounded(){/*{{{*/
    20072007
    2008         Input2* input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(input);
     2008        Input2* input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(input);
    20092009        if(input->GetInputMax() > 0.){
    20102010                return true;
    20112011        }
    … …  
    22572257        GetInputListOnVertices(&b[0],BaseEnum);
    22582258        GetInputListOnVertices(&r[0],BedEnum);
    22592259        GetInputListOnVertices(&sl[0],SealevelEnum);
    2260         GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     2260        GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
    22612261        rho_water   = FindParam(MaterialsRhoSeawaterEnum);
    22622262        rho_ice     = FindParam(MaterialsRhoIceEnum);
    22632263        density     = rho_ice/rho_water;
    … …  
    23112311                        /*do nothing*/
    23122312                }
    23132313        }
    2314         this->AddInput2(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
     2314        this->AddInput2(MaskOceanLevelsetEnum,&phi[0],P1Enum);
    23152315
    23162316        /*Update inputs*/
    23172317        this->AddInput2(SurfaceEnum,&s[0],P1Enum);

  • ../trunk-jpl/src/c/classes/Elements/Tria.cpp

     
    313313        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
    314314        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
    315315        Input2* B_input  = this->GetInput2(MaterialsRheologyBbarEnum);   _assert_(B_input);
    316         Input2* gr_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     316        Input2* gr_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    317317        Input2* bs_input = this->GetInput2(BaseEnum);                    _assert_(bs_input);
    318318        Input2* smax_fl_input = this->GetInput2(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
    319319        Input2* smax_gr_input = this->GetInput2(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
    … …  
    13651365        Element::GetInputListOnVertices(&bed[0],BedEnum);
    13661366        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
    13671367        Element::GetInputListOnVertices(&pressure[0],PressureEnum);
    1368         Element::GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     1368        Element::GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
    13691369        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
    13701370        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
    13711371        IssmDouble gravity   = FindParam(ConstantsGEnum);
    … …  
    15711571        IssmDouble         f1,f2;
    15721572
    15731573        /*Recover parameters and values*/
    1574         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1574        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    15751575
    15761576        /*Be sure that values are not zero*/
    15771577        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    16271627
    16281628        /*Recover parameters and values*/
    16291629        parameters->FindParam(&domaintype,DomainTypeEnum);
    1630         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1630        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    16311631
    16321632        /*Be sure that values are not zero*/
    16331633        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    28772877
    28782878        /*Make sure there is a grounding line here*/
    28792879        if(!IsIceInElement()) return 0;
    2880         if(!IsZeroLevelset(MaskGroundediceLevelsetEnum)) return 0;
     2880        if(!IsZeroLevelset(MaskOceanLevelsetEnum)) return 0;
    28812881
    28822882        /*Scaled not implemented yet...*/
    28832883        _assert_(!scaled);
    … …  
    28932893
    28942894        /*Recover parameters and values*/
    28952895        parameters->FindParam(&domaintype,DomainTypeEnum);
    2896         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     2896        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    28972897
    28982898        /*Be sure that values are not zero*/
    28992899        if(gl[0]==0.) gl[0]=gl[0]+epsilon;
    … …  
    38253825        density=rho_ice/rho_water;
    38263826        Element::GetInputListOnVertices(&h[0],ThicknessEnum);
    38273827        Element::GetInputListOnVertices(&r[0],BedEnum);
    3828         Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     3828        Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
    38293829
    38303830        /*go through vertices, and figure out which ones are grounded and want to unground: */
    38313831        for(int i=0;i<NUMVERTICES;i++){
    … …  
    38963896
    38973897        /*Get inputs*/
    38983898        Input2* slope_input=this->GetInput2(BedSlopeXEnum);                             _assert_(slope_input);
    3899         Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     3899        Input2* groundedicelevelset_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedicelevelset_input);
    39003900        vertexonbase = xNew<IssmDouble>(numnodes);
    39013901        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    39023902
    … …  
    46424642        /*Get material parameters :*/
    46434643        rho_ice=FindParam(MaterialsRhoIceEnum);
    46444644        Input2* floatingmelt_input = this->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    4645         Input2* gllevelset_input   = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4645        Input2* gllevelset_input   = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    46464646        Input2* scalefactor_input  = NULL;
    46474647        if(scaled==true){
    46484648                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    … …  
    46874687        /*Get material parameters :*/
    46884688        rho_ice=FindParam(MaterialsRhoIceEnum);
    46894689        Input2* groundedmelt_input = this->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    4690         Input2* gllevelset_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4690        Input2* gllevelset_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    46914691        Input2* scalefactor_input = NULL;
    46924692        if(scaled==true){
    46934693                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    … …  
    56225622        }
    56235623
    56245624        /*early return if we are fully floating:*/
    5625         Input2* gr_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     5625        Input2* gr_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    56265626        if (gr_input->GetInputMax()<=0){
    56275627                constant=0; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
    56285628                *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
    … …  
    61286128        if(!IsIceOnlyInElement() && !IsWaterInElement()) return;
    61296129
    61306130        /*early return if we are fully floating: */
    6131         Input2* gr_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     6131        Input2* gr_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    61326132        if(gr_input->GetInputMax()<=0)return;
    61336133
    61346134        /*recover computational flags: */

  • ../trunk-jpl/src/c/analyses/HydrologyGlaDSAnalysis.cpp

     
    135135                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    136136        }
    137137        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    138         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     138        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    139139        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.bump_height",HydrologyBumpHeightEnum);
    140140        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.sheet_conductivity",HydrologySheetConductivityEnum);
    141141        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.neumannflux",HydrologyNeumannfluxEnum);

  • ../trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp

     
    353353        element->GetVerticesCoordinatesBase(&xyz_list_base);
    354354        element->GetInputValue(&approximation,ApproximationEnum);
    355355        Input2* base_input=element->GetInput2(BaseEnum);                                               _assert_(base_input);
    356         Input2* groundedice_input=element->GetInput2(MaskGroundediceLevelsetEnum);                     _assert_(groundedice_input);
     356        Input2* groundedice_input=element->GetInput2(MaskOceanLevelsetEnum);                     _assert_(groundedice_input);
    357357        Input2* groundedice_melting_input=element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
    358358        Input2* floatingice_melting_input=element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingice_melting_input);
    359359        Input2* vx_input=element->GetInput2(VxEnum);                                                   _assert_(vx_input);

  • ../trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp

     
    243243                case Domain2DhorizontalEnum:
    244244                        vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
    245245                        vy_input=basalelement->GetInput2(VyEnum); _assert_(vy_input);
    246                         gr_input=basalelement->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     246                        gr_input=basalelement->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    247247                        break;
    248248                case Domain3DEnum:
    249249                        vx_input=basalelement->GetInput2(VxAverageEnum); _assert_(vx_input);
    250250                        vy_input=basalelement->GetInput2(VyAverageEnum); _assert_(vy_input);
    251                         gr_input=basalelement->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     251                        gr_input=basalelement->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
    252252                        break;
    253253                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    254254        }

  • ../trunk-jpl/src/c/analyses/HydrologyShaktiAnalysis.cpp

     
    105105                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    106106        }
    107107        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    108         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     108        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    109109        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    110110        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
    111111        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.head",HydrologyHeadEnum);

  • ../trunk-jpl/src/c/analyses/HydrologyPismAnalysis.cpp

     
    3232
    3333        /*Add input to elements*/
    3434        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    35         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     35        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    3636        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    3737        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.drainage_rate",HydrologyDrainageRateEnum);
    3838        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);

  • ../trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp

     
    149149        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
    150150        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
    151151        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    152         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     152        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    153153        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    154154        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
    155155        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
    … …  
    621621        element->FindParam(&stabilization,MasstransportStabilizationEnum);
    622622        Input2* gmb_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
    623623        Input2* fmb_input        = element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
    624         Input2* gllevelset_input = element->GetInput2(MaskGroundediceLevelsetEnum);              _assert_(gllevelset_input);
     624        Input2* gllevelset_input = element->GetInput2(MaskOceanLevelsetEnum);              _assert_(gllevelset_input);
    625625        Input2* ms_input         = element->GetInput2(SmbMassBalanceEnum);                       _assert_(ms_input);
    626626        Input2* thickness_input  = element->GetInput2(ThicknessEnum);                            _assert_(thickness_input);
    627627        Input2* vxaverage_input  = element->GetInput2(VxAverageEnum);                                                                           _assert_(vxaverage_input);
    … …  
    736736        Input2* gmb_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(gmb_input);
    737737        Input2* fmb_input        = element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(fmb_input);
    738738        Input2* ms_input         = element->GetInput2(SmbMassBalanceEnum);                      _assert_(ms_input);
    739         Input2* gllevelset_input = element->GetInput2(MaskGroundediceLevelsetEnum);             _assert_(gllevelset_input);
     739        Input2* gllevelset_input = element->GetInput2(MaskOceanLevelsetEnum);             _assert_(gllevelset_input);
    740740        Input2* thickness_input  = element->GetInput2(ThicknessEnum);                           _assert_(thickness_input);
    741741
    742742   /*Recover portion of element that is grounded*/
    … …  
    857857        basalelement->GetInputListOnVertices(&oldthickness[0],ThicknessOldEnum);
    858858        basalelement->GetInputListOnVertices(&oldbase[0],BaseOldEnum);
    859859        basalelement->GetInputListOnVertices(&oldsurface[0],SurfaceOldEnum);
    860         basalelement->GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     860        basalelement->GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
    861861        basalelement->GetInputListOnVertices(&sealevel[0],SealevelEnum);
    862862        basalelement->GetInputListOnVertices(&cumdeltathickness[0],SealevelriseCumDeltathicknessOldEnum);
    863863
    … …  
    10691069        element->FindParam(&stabilization,MasstransportStabilizationEnum);
    10701070        Input2* gmb_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
    10711071        Input2* fmb_input        = element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
    1072         Input2* gllevelset_input = element->GetInput2(MaskGroundediceLevelsetEnum);              _assert_(gllevelset_input);
     1072        Input2* gllevelset_input = element->GetInput2(MaskOceanLevelsetEnum);              _assert_(gllevelset_input);
    10731073        Input2* ms_input         = element->GetInput2(SmbMassBalanceEnum);                       _assert_(ms_input);
    10741074        Input2* vxaverage_input  = element->GetInput2(VxAverageEnum);                                                                           _assert_(vxaverage_input);
    10751075        Input2* vyaverage_input  = element->GetInput2(VyAverageEnum);                                                                           _assert_(vyaverage_input);

  • ../trunk-jpl/src/c/analyses/SealevelriseAnalysis.cpp

     
    3434        }
    3535
    3636        /*Create inputs: */
    37         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     37        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    3838        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    3939        //those only if we have requested geodetic computations:
    4040        iomodel->FetchData(&geodetic,"md.slr.geodetic");

  • ../trunk-jpl/src/c/analyses/GLheightadvectionAnalysis.cpp

     
    222222                IssmDouble *bed       = xNew<IssmDouble>(numnodes);
    223223                IssmDouble *ls_active = xNew<IssmDouble>(numnodes);
    224224
    225                 element->GetInputListOnNodes(&mask[0],MaskGroundediceLevelsetEnum);
     225                element->GetInputListOnNodes(&mask[0],MaskOceanLevelsetEnum);
    226226                element->GetInputListOnNodes(&bed[0],BaseEnum);
    227227                element->GetInputListOnNodes(&ls_active[0],IceMaskNodeActivationEnum);
    228228

  • ../trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp

     
    6363                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    6464        }
    6565        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    66         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     66        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    6767        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    6868        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum);
    6969

  • ../trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp

     
    160160        }
    161161
    162162        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
    163         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     163        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    164164        if(ismovingfront){
    165165                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    166166                        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes

  • ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

     
    102102                        iomodel->FetchData(&vertices_type,NULL,NULL,"md.flowequation.vertex_equation");
    103103                        iomodel->FetchData(&nodeonFS,NULL,NULL,"md.flowequation.borderFS");
    104104                        iomodel->FetchData(&nodeonbase,NULL,NULL,"md.mesh.vertexonbase");
    105                         iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.groundedice_levelset");
     105                        iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.ocean_levelset");
    106106                        if(iomodel->domaintype==Domain3DEnum){
    107107                                iomodel->FetchData(&spcvz,&Mz,&Nz,"md.stressbalance.spcvz");
    108108                        }
    … …  
    129129                        iomodel->DeleteData(vertices_type,"md.flowequation.vertex_equation");
    130130                        iomodel->DeleteData(nodeonFS,"md.flowequation.borderFS");
    131131                        iomodel->DeleteData(nodeonbase,"md.mesh.vertexonbase");
    132                         iomodel->DeleteData(groundedice_ls,"md.mask.groundedice_levelset");
     132                        iomodel->DeleteData(groundedice_ls,"md.mask.ocean_levelset");
    133133
    134134                        /*Pressure spc*/
    135135                        int count = constraints->Size();
    … …  
    201201        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,"md.flowequation.borderHO");
    202202        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,"md.flowequation.borderFS");
    203203        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,"md.mesh.vertexonbase");
    204         if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.groundedice_levelset");
     204        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.ocean_levelset");
    205205        iomodel->FetchData(&vertices_type,NULL,NULL,"md.flowequation.vertex_equation");
    206206        iomodel->FetchData(&surface,NULL,NULL,"md.geometry.surface");
    207207        iomodel->FetchData(&z,NULL,NULL,"md.mesh.z");
    … …  
    431431        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonHO,"md.flowequation.borderHO");
    432432        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonFS,"md.flowequation.borderFS");
    433433        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonbase,"md.mesh.vertexonbase");
    434         if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(groundedice_ls,"md.mask.groundedice_levelset");
     434        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(groundedice_ls,"md.mask.ocean_levelset");
    435435        iomodel->DeleteData(vertices_type,"md.flowequation.vertex_equation");
    436436        iomodel->DeleteData(surface,"md.geometry.surface");
    437437        iomodel->DeleteData(z,"md.mesh.z");
    … …  
    495495        /*Create Riffront loads for rifts: */
    496496        if(numrifts){
    497497                iomodel->FetchData(&riftinfo,&numriftsegments,NULL,"md.rifts.riftstruct");
    498                 iomodel->FetchData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.groundedice_levelset");
     498                iomodel->FetchData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.ocean_levelset");
    499499                for(i=0;i<numriftsegments;i++){
    500500                        if(iomodel->my_elements[reCast<int,IssmDouble>(*(riftinfo+RIFTINFOSIZE*i+2))-1]){
    501501                                loads->AddObject(new Riftfront(count+1,i,iomodel));
    … …  
    502502                                count++;
    503503                        }
    504504                }
    505                 iomodel->DeleteData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.groundedice_levelset");
     505                iomodel->DeleteData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.ocean_levelset");
    506506                xDelete<IssmDouble>(riftinfo);
    507507        }
    508508}/*}}}*/
    … …  
    757757        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
    758758        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
    759759        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    760         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     760        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    761761        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum,0.);
    762762        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum,0.);
    763763        iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcex",LoadingforceXEnum);
    … …  
    14411441        /*Recover portion of element that is grounded*/
    14421442        if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list);
    14431443        if(friction_style==SubelementFriction2Enum){
    1444                 gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     1444                gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    14451445                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    14461446           gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    14471447        }
    … …  
    24792479        /*Recover portion of element that is grounded*/
    24802480        if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list_base);
    24812481        if(friction_style==SubelementFriction2Enum){
    2482                 gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     2482                gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    24832483                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    24842484                gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    24852485        }
    … …  
    39623962        if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list_base);
    39633963        if(friction_style==SubelementFriction2Enum){
    39643964                if(domaintype==Domain2DverticalEnum) _error_("Subelement Friction 2 not implemented yet for Flowline");
    3965                 gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     3965                gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
    39663966                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    39673967                //gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    39683968                gauss=element->NewGaussBase(3);

  • ../trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp

     
    792792        IssmDouble*             groundedice =   xNew<IssmDouble>(numnodes);
    793793
    794794        basalelement->GetInputListOnVertices(&meltingrate[0],BasalforcingsGroundediceMeltingRateEnum);
    795         basalelement->GetInputListOnVertices(&groundedice[0],MaskGroundediceLevelsetEnum);
     795        basalelement->GetInputListOnVertices(&groundedice[0],MaskOceanLevelsetEnum);
    796796
    797797        /*if melting rate is not positive and node is not floating, deactivate*/
    798798        for(int i=0;i<numnodes;i++){

  • ../trunk-jpl/src/c/analyses/ThermalAnalysis.cpp

     
    134134        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
    135135        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
    136136        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    137         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     137        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    138138        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    139139                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    140140                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);

  • ../trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp

     
    138138        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
    139139        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
    140140        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    141         iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     141        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    142142        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    143143                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    144144                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);

  • ../trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp

     
    295295        /*Retrieve all inputs and parameters*/
    296296        basalelement->GetVerticesCoordinates(&xyz_list);
    297297        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    298         Input2* groundedice_input   = basalelement->GetInput2(MaskGroundediceLevelsetEnum);              _assert_(groundedice_input);
     298        Input2* groundedice_input   = basalelement->GetInput2(MaskOceanLevelsetEnum);              _assert_(groundedice_input);
    299299        Input2* gmb_input           = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
    300300        Input2* fmb_input           = basalelement->GetInput2(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
    301301        Input2* base_input          = basalelement->GetInput2(BaseEnum);                                 _assert_(base_input);
    … …  
    410410                if(!element->IsOnBase()) continue;
    411411
    412412                int             numnodes = element->GetNumberOfNodes();
    413                 Input2* groundedice_input = element->GetInput2(MaskGroundediceLevelsetEnum);  _assert_(groundedice_input);
     413                Input2* groundedice_input = element->GetInput2(MaskOceanLevelsetEnum);  _assert_(groundedice_input);
    414414                Input2* onbase_input       = element->GetInput2(MeshVertexonbaseEnum);          _assert_(onbase_input);
    415415                Input2* base_input        = element->GetInput2(BaseEnum);                     _assert_(base_input);
    416416
Note: See TracBrowser for help on using the repository browser.