Changeset 27317


Ignore:
Timestamp:
10/20/22 09:29:37 (3 years ago)
Author:
Eric.Larour
Message:

Merging back into trunk.

Location:
issm/branches/trunk-larour-SLPS2022
Files:
5 added
11 edited

Legend:

Unmodified
Added
Removed

  • issm/branches/trunk-larour-SLPS2022/src/m/classes/clusters/pfe.m

    r27228 r27317  
    5151                        disp(sprintf('    queue: %s',cluster.queue));
    5252                        disp(sprintf('    time: %i',cluster.time));
    53                         disp(sprintf('    processor: %sn',cluster.processor));
     53                        disp(sprintf('    processor: %s',cluster.processor));
    5454                        disp(sprintf('    srcpath: %s',cluster.srcpath));
    5555                        disp(sprintf('    extpkgpath: %s',cluster.extpkgpath));

  • issm/branches/trunk-larour-SLPS2022/src/m/classes/dslmme.m

    r27091 r27317  
    3838                                return;
    3939                        end
     40                        nt=length(self.global_average_thermosteric_sea_level);
    4041                        for i=1:length(self.global_average_thermosteric_sea_level),
    4142                                md = checkfield(md,'field',self.global_average_thermosteric_sea_level{i},'NaN',1,'Inf',1);
    … …  
    5051
    5152                        %check time stamps: they should all be in seconds
    52                         %global_average_thermosteric_sea_level {{{
    53                         for i=1:nt,
    54                                 h=self.global_average_thermosteric_sea_level{i};
    55                                 times=h(end,:);
    56                                 avgtime=mean(times);
    57                                 if(avgtime<10000)
    58                                         error('dslmme checkconsistency error messages: time tags for global_average_thermosteric_sea_level should be in seconds!');
    59                                 end
    60                         end %}}}
    61                         %sea_surface_height_above_geoid {{{
    62                         for i=1:nt,
    63                                 h=self.sea_surface_height_above_geoid{i};
    64                                 times=h(end,:);
    65                                 avgtime=mean(times)
    66                                 if(avgtime<10000)
    67                                         error('dslmme checkconsistency error messages: time tags for sea_surface_height_above_geoid should be in seconds!');
    68                                 end
    69                         end %}}}
    70                         %sea_water_pressure_at_sea_floor {{{
    71                         for i=1:nt,
    72                                 h=self.sea_water_pressure_at_sea_floor{i};
    73                                 times=h(end,:);
    74                                 avgtime=mean(times)
    75                                 if(avgtime<10000)
    76                                         error('dslmme checkconsistency error messages: time tags for sea_water_pressure_at_sea_floor should be in seconds!');
    77                                 end
    78                         end %}}}
    79 
     53                        checkseconds=0;
     54                        if checkseconds,
     55                                %global_average_thermosteric_sea_level {{{
     56                                for i=1:nt,
     57                                        h=self.global_average_thermosteric_sea_level{i};
     58                                        times=h(end,:);
     59                                        avgtime=mean(times);
     60                                        if(avgtime<10000)
     61                                                error('dslmme checkconsistency error messages: time tags for global_average_thermosteric_sea_level should be in seconds!');
     62                                        end
     63                                end %}}}
     64                                %sea_surface_height_above_geoid {{{
     65                                for i=1:nt,
     66                                        h=self.sea_surface_height_above_geoid{i};
     67                                        times=h(end,:);
     68                                        avgtime=mean(times)
     69                                        if(avgtime<10000)
     70                                                error('dslmme checkconsistency error messages: time tags for sea_surface_height_above_geoid should be in seconds!');
     71                                        end
     72                                end %}}}
     73                                %sea_water_pressure_at_sea_floor {{{
     74                                for i=1:nt,
     75                                        h=self.sea_water_pressure_at_sea_floor{i};
     76                                        times=h(end,:);
     77                                        avgtime=mean(times)
     78                                        if(avgtime<10000)
     79                                                error('dslmme checkconsistency error messages: time tags for sea_water_pressure_at_sea_floor should be in seconds!');
     80                                        end
     81                                end %}}}
     82                        end
    8083                end % }}}
    8184                function disp(self) % {{{

  • issm/branches/trunk-larour-SLPS2022/src/m/classes/mmeofflinesolidearthsolution.m

    r27248 r27317  
    5151
    5252                        %check time stamps: they should all be in seconds
     53                        checkseconds=0;
     54                        if checkseconds,
    5355                        %displacementup {{{
    5456                        for i=1:sup,
    … …  
    5759                                avgtime=mean(times);
    5860                                if(avgtime<10000)
    59                                         error('dslmme checkconsistency error messages: time tags for displacementup should be in seconds!');
     61                                        error('mmeofflinesolidearthsolution checkconsistency error messages: time tags for displacementup should be in seconds!');
    6062                                end
    6163                        end %}}}
    … …  
    8789                                end
    8890                        end %}}}
    89 
     91                        end
    9092                end % }}}
    9193                function disp(self) % {{{
    … …  
    99101                function marshall(self,prefix,md,fid) % {{{
    100102                        WriteData(fid,prefix,'data',4,'name','md.solidearth.external.nature','format','Integer'); %code 4 for mmeofflinesolidearthsolution class
    101                         WriteData(fid,prefix,'data',self.modelid,'name','md.solidearth.external.modelid','format','Integer');
     103                        WriteData(fid,prefix,'data',self.modelid,'name','md.solidearth.external.modelid','format','Double');
    102104                        nummodels=length(self.displacementeast);
    103105                        WriteData(fid,prefix,'name','md.solidearth.external.nummodels','data',nummodels,'format','Integer');

  • issm/branches/trunk-larour-SLPS2022/src/m/classes/modellist.m

    r19040 r27317  
    88                models  = cell(0,1);
    99                cluster = generic();
     10                name = '';
     11        end
     12        properties (SetAccess=public)
     13                runtimename = '';
    1014        end
    1115        methods
    … …  
    122126
    123127                end % }}}
    124                 function self = modellist(varargin) % {{{
     128                function self = modellist(name,cluster,varargin) % {{{
    125129
    126130                        %initialize list
    127131                        if nargin==0,
    128132                                %Do nothing,
    129                         elseif nargin==1,
    130                                 if ~isa(varargin{1},'cell'),
    131                                         error('not supported yet');
    132                                 end
    133 
     133                        else
     134
     135                                self.name=name;
     136                                self.cluster=cluster;
    134137                                celllist=varargin{1};
    135138
    … …  
    145148                                        end
    146149                                end
    147 
    148150                                self.models  = celllist;
    149                                 self.cluster = self.models{1}.cluster;
    150151                        end
    151152                end % }}}
    … …  
    208209                        delete('ModelResults.tar.gz');
    209210                end % }}}
    210                 function self = solve(self,varargin)% {{{
     211                function self = solve(self,solutiontype,varargin)% {{{
    211212                        %SOLVE - apply solution sequence for  a list of models. Used in batch mode.
    212213                        %
    213214                        %   Usage:
    214                         %      self=solve(self,varargin)
     215                        %      self=solve(self,solutiontype,varargin)
    215216                        %      where varargin is a lit of paired arguments.
    216                         %      arguments can be: 'analysis_type': 'stressbalance','thermal','masstransport','transient'
    217217                        %
    218218                        %   Examples:
    219                         %      self=solve(self,'analysis_type','stressbalance');
    220 
     219                        %      self=solve(self,'tr','batch','yes');
     220
     221                        disp('Starting multiple solve');
     222                       
     223
     224                        %come up with a run time name:
     225                        c=clock;
     226                        self.runtimename=sprintf('%s-%02i-%02i-%04i-%02i-%02i-%02i-%i',self.name,c(2),c(3),c(1),c(4),c(5),floor(c(6)),feature('GetPid'));
     227
     228                       
    221229                        %recover options
    222                         options=pairoptions(varargin{:});
    223 
    224                         %add default options
    225                         options=process_solve_options(options);
     230                        options=pairoptions(varargin{:},'solutionstring',solutiontype);
    226231
    227232                        %length of list
    228233                        nummodels=length(self.models);
    229234
    230                         %name of queue: to make it unique, add a time stamp
    231                         name=[self.name '-' datestr(now,1) '-' datestr(now,'HH-MM-SS') ];
    232 
    233                         %name of cluster will be first name of list
    234                         cluster=self.cluster;
    235 
    236                         %Figure out parameters for this particular cluster
    237                         cluster_rc_location=which('cluster.rc');
    238                         [codepath,executionpath]=ClusterParameters(cluster,cluster_rc_location);
    239 
     235                        %come up with unique names for all our models:
     236                        for i=1:nummodels,
     237                                self.models{i}.miscellaneous.name=sprintf('%s%i',self.models{i}.miscellaneous.name,i);
     238                        end
     239
     240                        names={};
     241                       
    240242                        %solve in batch mode:
    241243                        for i=1:nummodels,
    … …  
    244246                                mdex=self.models{i};
    245247
    246                                 %recover some fields
    247                                 mdex.analysis_type=options.analysis_type;
    248 
    249                                 mdex.name=[name '-' num2str(i) 'vs' num2str(nummodels)];
    250                                 mdex.time=self.time;
    251                                 mdex.queue=self.queue;
    252                                 mdex.cluster=self.cluster;
    253                                 if ~isnan(self.np),
    254                                         mdex.np=self.np;
    255                                 end
    256 
    257248                                %call solve in batch mode:
    258                                 if strcmpi(cluster,oshostname),
     249                                disp(sprintf('   marshalling model %i/%i',i,nummodels));
     250                                if strcmpi(self.cluster,oshostname),
    259251                                        mdex=solve(mdex,varargin{:});
    260252                                else
    261                                         mdex=solve(mdex,varargin{:},'batch','yes','directory',name);
     253                                        mdex=solve(mdex,solutiontype,varargin{:},'batch','yes');
    262254                                end
    263255
    264256                                %feed back
    265257                                self.models{i}=mdex;
     258                               
     259                                %record name:
     260                                names{end+1}=sprintf('%s.tar.gz',mdex.private.runtimename);
    266261                        end
    267262
    268263                        %locally, we are done.
    269                         if strcmpi(cluster,oshostname),
     264                        if strcmpi(self.cluster,oshostname),
    270265                                return
    271266                        end
    272 
    273                         %now, tar all the files and then erase them.
    274                         eval(['!find -iname ''' name '-*'' > file_list.txt']);
    275                         !tar zcvf ModelList.tar.gz --files-from file_list.txt
    276                         !rm -rf *.bin *.queue file_list.txt
     267                       
     268                        %tar files:
     269                        tar('ModelList.tar.gz',names);
    277270
    278271                        %still have to build a launching script.
    279                         BuildMultipleQueueingScript(cluster,name,executionpath,codepath);
     272                        self.BuildQueueingScript(solutiontype);
     273
     274                        %upload data
     275                        self.UploadQueueJob();
    280276
    281277                        %launch jobs on remote cluster
    282                         LaunchMultipleQueueJob(cluster,name,executionpath);
     278                        self.LaunchQueueJob();
    283279
    284280                        %erase files:
    285                         delete([name '.queue']);
    286281                        delete('ModelList.tar.gz');
    287282
    288                         %save name:
    289                         self.name=name;
    290283                end % }}}
     284                function self = loadresults(self) % {{{
     285
     286                        nummodels=length(self.models);
     287                        cluster=self.cluster;
     288                       
     289                        %solve in batch mode:
     290                        directory=sprintf('%s/Interactive%i',cluster.executionpath,cluster.interactive);
     291                        filelist={};
     292                        for i=1:nummodels,
     293                                filelist{end+1}= sprintf('%s/%s.outbin',self.models{i}.private.runtimename,self.models{i}.miscellaneous.name);
     294                        end
     295                        issmscpin(cluster.name,cluster.login,cluster.port,directory,filelist);
     296
     297                        %load results:
     298                        for i=1:nummodels,
     299                                self.models{i}=loadresultsfromdisk(self.models{i},sprintf('%s.outbin',self.models{i}.miscellaneous.name));
     300                        end
     301
     302                end %}}}
     303                function num= nummodels(self) % {{{
     304                        num=length(self.models);
     305                end %}}}
     306                function BuildQueueingScript(self,solution)% {{{
     307
     308                        scriptname=[self.runtimename '.queue'];
     309                        cluster=self.cluster;
     310                        dirname=self.runtimename;
     311                        modelname=self.name;
     312                        nummodels=length(self.models);
     313
     314                        %recover and process solve options %{{{
     315                        if strcmpi(solution,'sb') || strcmpi(solution,'Stressbalance')
     316                                solution = 'StressbalanceSolution';
     317                        elseif strcmpi(solution,'mt') || strcmpi(solution,'Masstransport')
     318                                solution = 'MasstransportSolution';
     319                        elseif strcmpi(solution,'oceant') || strcmpi(solution,'Oceantransport')
     320                                solution = 'OceantransportSolution';
     321                        elseif strcmpi(solution,'th') || strcmpi(solution,'Thermal')
     322                                solution = 'ThermalSolution';
     323                        elseif strcmpi(solution,'ss') || strcmpi(solution,'Steadystate')
     324                                solution = 'SteadystateSolution';
     325                        elseif strcmpi(solution,'tr') || strcmpi(solution,'Transient')
     326                                solution = 'TransientSolution';
     327                        elseif strcmpi(solution,'mc') || strcmpi(solution,'Balancethickness')
     328                                solution = 'BalancethicknessSolution';
     329                        elseif strcmpi(solution,'Balancethickness2')
     330                                solution = 'Balancethickness2Solution';
     331                        elseif strcmpi(solution,'mcsoft') || strcmpi(solution,'BalancethicknessSoft')
     332                                solution = 'BalancethicknessSoftSolution';
     333                        elseif strcmpi(solution,'bv') || strcmpi(solution,'Balancevelocity')
     334                                solution = 'BalancevelocitySolution';
     335                        elseif strcmpi(solution,'bsl') || strcmpi(solution,'BedSlope')
     336                                solution = 'BedSlopeSolution';
     337                        elseif strcmpi(solution,'ssl') || strcmpi(solution,'SurfaceSlope')
     338                                solution = 'SurfaceSlopeSolution';
     339                        elseif strcmpi(solution,'hy') || strcmpi(solution,'Hydrology')
     340                                solution = 'HydrologySolution';
     341                        elseif strcmpi(solution,'da') || strcmpi(solution,'DamageEvolution')
     342                                solution = 'DamageEvolutionSolution';
     343                        elseif strcmpi(solution,'gia') || strcmpi(solution,'Gia')
     344                                solution = 'GiaSolution';
     345                        elseif strcmpi(solution,'lv') || strcmpi(solution,'Love')
     346                                solution = 'LoveSolution';
     347                        elseif strcmpi(solution,'esa') || strcmpi(solution,'Esa')
     348                                solution = 'EsaSolution';
     349                        elseif strcmpi(solution,'smp') || strcmpi(solution,'Sampling')
     350                                solution = 'SamplingSolution';   
     351                        else
     352                                error(['solution ' solution ' not supported!']);
     353                        end
     354                        %}}}
     355
     356                        executable='issm.exe';
     357
     358                        fid=fopen([modelname '.queue'],'w');
     359                        fprintf(fid,'#PBS -S /bin/bash\n');
     360                        fprintf(fid,'#PBS -l select=%i:ncpus=%i:model=%s\n',cluster.numnodes,cluster.cpuspernode,cluster.processor);
     361                        fprintf(fid,'#PBS -l walltime=%i\n',cluster.time*60); %walltime is in seconds.
     362                        fprintf(fid,'#PBS -q %s\n',cluster.queue);
     363                        fprintf(fid,'#PBS -W group_list=%s\n',cluster.grouplist);
     364                        fprintf(fid,'#PBS -m e\n');
     365                        fprintf(fid,'#PBS -o %s/%s/%s.outlog \n',cluster.executionpath,dirname,modelname);
     366                        fprintf(fid,'#PBS -e %s/%s/%s.errlog \n\n',cluster.executionpath,dirname,modelname);
     367                        fprintf(fid,'. /usr/share/modules/init/bash\n\n');
     368                        for i=1:numel(cluster.modules), fprintf(fid,['module load ' cluster.modules{i} '\n']); end
     369                        fprintf(fid,'export PATH="$PATH:."\n\n');
     370                        fprintf(fid,'export MPI_LAUNCH_TIMEOUT=520\n');
     371                        fprintf(fid,'export MPI_GROUP_MAX=64\n\n');
     372                        fprintf(fid,'export ISSM_DIR="%s"\n',cluster.srcpath); %FIXME
     373
     374                        fprintf(fid,'source $ISSM_DIR/etc/environment.sh\n');       %FIXME
     375                        fprintf(fid,'cd %s/%s/\n\n',cluster.executionpath,dirname);
     376
     377                        for i=1:nummodels,
     378                                fprintf(fid,'cd %s && mpiexec -np %i /u/scicon/tools/bin/mbind.x %s/%s %s %s/%s/%s && cd ..\n',self.models{i}.private.runtimename,cluster.nprocs(),cluster.codepath,executable,solution,cluster.executionpath,self.runtimename,self.models{i}.private.runtimename);
     379                        end
     380                        fclose(fid);
     381
     382                        %in interactive mode, create a run file, and errlog and outlog file
     383                        if cluster.interactive,
     384                                fid=fopen([modelname '.run'],'w');
     385                                for i=1:nummodels,
     386                                        fprintf(fid,'cd %s && mpiexec -np %i /u/scicon/tools/bin/mbind.x %s/%s %s %s/%s %s && cd ..\n',self.models{i}.private.runtimename,cluster.nprocs(),cluster.codepath,executable,solution,[cluster.executionpath '/Interactive' num2str(cluster.interactive)] ,self.models{i}.private.runtimename,self.models{i}.miscellaneous.name);
     387                                end
     388                                fclose(fid);
     389                                fid=fopen([modelname '.errlog'],'w'); fclose(fid);
     390                                fid=fopen([modelname '.outlog'],'w'); fclose(fid);
     391                        end
     392                end% }}}
     393                function UploadQueueJob(self) % {{{
     394
     395                        cluster=self.cluster;
     396
     397                        %compress the files into one zip.
     398                        compressstring=sprintf('tar -zcf %s.tar.gz ModelList.tar.gz %s.queue ',self.name,self.name);
     399                        if cluster.interactive,
     400                                compressstring = sprintf('%s %s.run %s.errlog %s.outlog',compressstring, self.name,self.name,self.name);
     401                        end
     402                        system(compressstring);
     403
     404                        disp('uploading input file and queueing script');
     405                        if cluster.interactive,
     406                                directory=[cluster.executionpath '/Interactive' num2str(cluster.interactive)];
     407                        else
     408                                directory=cluster.executionpath;
     409                        end
     410
     411                        issmscpout(cluster.name,directory,cluster.login,cluster.port,{[self.name '.tar.gz']});
     412
     413                end
     414                %}}}
     415                function LaunchQueueJob(self)% {{{
     416                        %LAUNCHQUEUEJOB - LAUNCH MULTIPLE QUEUEING SCRIPT ON PFE CLUSTER
     417                        %
     418                        %   Usage:
     419                        %      LaunchQueueJob(self)
     420
     421                        cluster=self.cluster;
     422                        modelname=self.name;
     423                        nummodels=length(self.models);
     424
     425                        disp('uploading inputs files');
     426                        if cluster.interactive,
     427                                launchcommand=sprintf('cd %s/Interactive%i && tar -zxf %s.tar.gz && tar -zxvf ModelList.tar.gz ',cluster.executionpath,cluster.interactive,modelname);
     428                                for i=1:nummodels,
     429                                        launchcommand=sprintf('%s && mkdir %s && cd %s && mv ../%s.tar.gz ./ && tar -zxvf %s.tar.gz && cd .. ',launchcommand,self.models{i}.private.runtimename, ...
     430                                                self.models{i}.private.runtimename, self.models{i}.private.runtimename, self.models{i}.private.runtimename);
     431                                end
     432                        else
     433                                launchcommand=['cd ' cluster.executionpath ' && mkdir ' self.runtimename...
     434                                        ' && cd ' self.runtimename ' && mv ../' self.runtimename '.tar.gz ./ && tar -zxf ' dirname '.tar.gz && qsub ' modelname '.queue '];
     435                        end
     436
     437                        disp('launching solution sequence on remote cluster');
     438                        issmssh(cluster.name,cluster.login,cluster.port,launchcommand);
     439                end
    291440        end
    292441end
    293 
    294 function BuildMultipleQueueingScript(cluster,name,executionpath,codepath)% {{{
    295 %BUILDMULTIPLEQUEUEINGSCRIPT -
    296 %
    297 %   Usage:
    298 %      BuildMultipleQueueingScript(executionpath,codepath)
    299 
    300 disp('building queueing script');
    301 
    302 %First try and figure out if there is a special script for this particular cluster
    303 function_name=['BuildMultipleQueueingScript' cluster]
    304 
    305 %some specific treatment of identical cluster, gemini, castor and pollux
    306 if strcmpi(cluster,'castor') || strcmpi(cluster,'pollux'),
    307         function_name='BuildMultipleQueueingScriptgemini';
    308 end
    309 
    310 if exist(function_name,'file'),
    311         %Call this function:
    312         eval([function_name '(name,executionpath,codepath);']);
    313 else
    314         %Call the generic BuildQueueingScript:
    315         BuildMultipleQueueingScriptGeneric(name,executionpath,codepath);
    316 end
    317 end % }}}
    318 function BuildQueueingScriptgemini(name,executionpath,codepath)% {{{
    319 %BUILDQUEUEINGSCRIPTGEMINI - ...
    320 %
    321 %   Usage:
    322 %      BuildQueueingScriptgemini(md,executionpath,codepath)
    323 
    324 scriptname=[name '.queue'];
    325 
    326 fid=fopen(scriptname,'w');
    327 if fid==-1,
    328         error(['BuildQueueingScriptgeminierror message: could not open ' scriptname ' file for ascii writing']);
    329 end
    330 
    331 fprintf(fid,'#!/bin/sh\n');
    332 fprintf(fid,'cd %s\n',executionpath);
    333 fprintf(fid,'mkdir %s\n',name);
    334 fprintf(fid,'cd %s\n',name);
    335 fprintf(fid,'mv ../ModelList.tar.gz ./\n');
    336 fprintf(fid,'tar -zxvf ModelList.tar.gz\n');
    337 fprintf(fid,'foreach i (%s-*vs*.queue)\n',name);
    338 fprintf(fid,'qsub $i\n');
    339 fprintf(fid,'end\n');
    340 fclose(fid);
    341 end% }}}
    342 function LaunchMultipleQueueJob(cluster,name,executionpath)% {{{
    343 %LAUNCHMULTIPLEQUEUEJOB - ...
    344 %
    345 %   Usage:
    346 %      LaunchMultipleQueueJob(executionpath)
    347 
    348 %First try and figure out if there is a special script for thie particular cluster
    349 function_name=['LaunchMultipleQueueJob' cluster]
    350 
    351 %some specific treatment of identical cluster, gemini, castor and pollux
    352 if strcmpi(cluster,'castor') || strcmpi(cluster,'pollux'),
    353         function_name='LaunchMultipleQueueJobgemini';
    354 end
    355 
    356 if exist(function_name,'file'),
    357         %Call this function:
    358         eval([function_name '(cluster,name,executionpath);']);
    359 else
    360         %Call the generic LaunchMultipleQueueJob:
    361         LaunchMultipleQueueJobGeneric(cluster,name,executionpath);
    362 end
    363 end% }}}
    364 function md=LaunchMultipleQueueJobgemini(cluster,name,executionpath)% {{{
    365 %LAUNCHMULTIPLEQUEUEJOBGEMINI - Launch multiple queueing script on Gemini cluster
    366 %
    367 %   Usage:
    368 %      LaunchMultipleQueueJobgemini(cluster,name,executionpath)
    369 
    370 %first, check we have the binary file and the queueing script
    371 if ~exist([ name '.queue'],'file'),
    372         error('LaunchMultipleQueueJobgemini error message: queueing script issing, cannot go forward');
    373 end
    374 
    375 if ~exist('ModelList.tar.gz','file'),
    376         error('LaunchMultipleQueueJobgemini error message: inputs models file missing, cannot go forward');
    377 end
    378 
    379 %upload both files to cluster
    380 disp('uploading input file,  queueing script and variables script');
    381 eval(['!scp ModelList.tar.gz ' name '.queue '  cluster ':' executionpath]);
    382 
    383 disp('launching solution sequence on remote cluster');
    384 issmssh(cluster,login,['"cd ' executionpath ' && source ' name '.queue "']);
    385 end% }}}

  • issm/branches/trunk-larour-SLPS2022/src/m/contrib/larour/glacier_inventory.m

    r25758 r27317  
    183183                        %Go through O2 regions:
    184184                        for i=subsetregions,
    185                         %for i=33,
     185                        %for i=89:150,
    186186                                string=self.boxes(i).RGI_CODE;
    187187                                disp(['progressing with region ' num2str(i) ' ' string]);
    … …  
    210210                                                case 32, radius=60;
    211211                                                case 33, radius=10;
     212                                                case 36, radius=10;
    212213                                                case 41, radius=75;
    213214                                                case 42, radius=45;
     215                                                case 51, radius=10;
    214216                                                case 61, radius=66;
     217                                                case 63, radius=10;
    215218                                                case 68, radius=10;
     219                                                case 77, radius=10;
    216220                                                case 82, radius=30;
     221                                                case 83, radius=20;
     222                                                case 89, radius=20;
     223                                                case 90, radius=10;
     224                                                case 93, radius=10;
    217225                                                otherwise,
    218226                                        end % }}}

  • issm/branches/trunk-larour-SLPS2022/src/m/plot/applyoptions.m

    r27134 r27317  
    399399
    400400%coastlines
    401 if (strcmpi(getfieldvalue(options,'coastlines','off'),'on') | ...
    402         strcmpi(getfieldvalue(options,'coastlines','off'),'on'))
     401if (strcmpi(getfieldvalue(options,'coastlines','on'),'on') | ...
     402        strcmpi(getfieldvalue(options,'coastlines','on'),'on'))
    403403        plot_coastlines(md.mesh,options);
    404404end

  • issm/branches/trunk-larour-SLPS2022/src/m/plot/plot_coastlines.m

    r25685 r27317  
    98949894        hold on, p=plot(x,y,'k-');
    98959895        xlim(xl); ylim(yl);
    9896         set(p,'Color',getfieldvalue(options,'coast_color','k'));
     9896        set(p,'Color',getfieldvalue(options,'coast_color','w'));
    98979897        set(p,'LineWidth',getfieldvalue(options,'coast_linewidth',1));
    98989898else
    … …  
    99019901                [x,y,z]=AboveGround(coastlat,coastlon,mesh.r(1),1000);
    99029902                hold on, p=plot3(x,y,z,'k-');
    9903                 set(p,'Color',getfieldvalue(options,'coast_color','k'));
     9903                set(p,'Color',getfieldvalue(options,'coast_color','w'));
    99049904                set(p,'LineWidth',getfieldvalue(options,'coast_linewidth',1));
    99059905        else
    99069906                hold on,
     9907                warning off;
    99079908                p=polyshape(coastlon,coastlat);
    9908                 plot(p,'FaceColor','w','FaceAlpha',1);
     9909                warning on;
     9910                pp=plot(p,'FaceColor',getfieldvalue(options,'coast_color','w'),'FaceAlpha',getfieldvalue(options,'coast_alpha',1),...
     9911                        'LineWidth',getfieldvalue(options,'coast_linewidth',1),'EdgeColor',getfieldvalue(options,'coast_color','w'));
    99099912                if strcmpi(getfieldvalue(options,'coordcent','atlantic'),'pacific'),
    99109913                        xlim(getfieldvalue(options,'xlim',[-360 0]));

  • issm/branches/trunk-larour-SLPS2022/src/m/plot/processdatalatlong.m

    r25758 r27317  
    2424                data=[data; extradata];
    2525        elseif length(data)==length(md.mesh.elements),
    26                 datatype=1;
     26                datatype=2;
     27                data=averaging(md,data,0);
     28                extradata=griddata(x0,y0,data,xextra,yextra,'nearest');
     29                data=[data; extradata];
     30
    2731        end

  • issm/branches/trunk-larour-SLPS2022/test/NightlyRun/test2002.m

    r26842 r27317  
    7878%Solution parameters
    7979md.cluster.np=3;
     80md.cluster.codepath='/Users/larour/issm-trunks/trunk-SLPS/build-dak/bin';
    8081md.solidearth.settings.reltol=NaN;
    8182md.solidearth.settings.abstol=1e-3;

  • issm/branches/trunk-larour-SLPS2022/test/NightlyRun/test2090.m

    r26809 r27317  
    121121md.solidearth.settings.viscous=1;
    122122md.solidearth.settings.rotation=1;
     123error;
    123124md=solve(md,'tr');
    124125

  • issm/branches/trunk-larour-SLPS2022/test/NightlyRun/test2091.m

    r26884 r27317  
    2323defaultoptions={'KeepVertices',0,'MaxCornerAngle',0.0000000001,'NoBoundaryRefinement',1};
    2424md2d=bamg(model,'domain',dom,'subdomains',co,'hmin',100e3,'hmax',10000e3,defaultoptions{:});
     25%hmax a 3000
    2526
    2627colat=sqrt(md2d.mesh.x.^2+md2d.mesh.y.^2)/re;
    … …  
    145146%Solution parameters
    146147md.cluster.np=3;
     148md.cluster.codepath='/Users/larour/issm-trunks/trunk-SLPS/build-dak/bin';
    147149md.solidearth.settings.reltol=NaN;
    148150md.solidearth.settings.abstol=1e-3;
Note: See TracChangeset for help on using the changeset viewer.