Changeset 9614


Ignore:
Timestamp:
09/06/11 12:23:41 (14 years ago)
Author:
Mathieu Morlighem
Message:

Added classes/private.m class

Location:
issm/trunk/src/m
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/m/classes/clusters/castor.m

    r9571 r9614  
    5959                         %retrieve parameters
    6060                         modelname=md.name;
    61                          solution_type=md.solution_type;
     61                         solution_type=md.private.solution;
    6262
    6363                         %open file for writing:
    … …  
    8787                         
    8888                         %lauch command, to be executed via ssh
    89                          launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    90                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     89                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     90                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && qsub ' modelname '.queue '];
    9191
    9292                        if ~strcmpi(options.batch,'yes'),
    9393                               
    9494                                %compress the files into one zip.
    95                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     95                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    9696                                if md.dakota_analysis,
    9797                                        compressstring=[compressstring md.name '.qmu.in'];
    … …  
    100100                               
    101101                                disp('uploading input file and queueing script');
    102                                 issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     102                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.private.runtimename '.tar.gz']});
    103103                               
    104104                                disp('launching solution sequence on remote cluster');
    … …  
    115115
    116116                        %some check
    117                         if isempty(md.runtimename),
     117                        if isempty(md.private.runtimename),
    118118                                error('pfe Download error message: supply runtime name for results to be loaded!');
    119119                        end
    120120
    121121                        %Figure out the  directory where all the files are in:
    122                         directory=[cluster.executionpath '/' md.runtimename '/'];
     122                        directory=[cluster.executionpath '/' md.private.runtimename '/'];
    123123
    124124                        %What packages are we picking up from remote cluster

  • issm/trunk/src/m/classes/clusters/cosmos.m

    r9571 r9614  
    5959                         %retrieve parameters
    6060                         modelname=md.name;
    61                          solution_type=md.solution_type;
     61                         solution_type=md.private.solution;
    6262
    6363                         %open file for writing:
    … …  
    8686                         
    8787                         %lauch command, to be executed via ssh
    88                          launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    89                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub -S/bin/sh ' modelname '.queue '];
     88                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     89                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && qsub -S/bin/sh ' modelname '.queue '];
    9090
    9191                        if ~strcmpi(options.batch,'yes'),
    9292                               
    9393                                %compress the files into one zip.
    94                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     94                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    9595                                if md.dakota_analysis,
    9696                                        compressstring=[compressstring md.name '.qmu.in'];
    … …  
    9999                               
    100100                                disp('uploading input file and queueing script');
    101                                 issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     101                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.private.runtimename '.tar.gz']});
    102102                               
    103103                                disp('launching solution sequence on remote cluster');
    … …  
    114114
    115115                        %some check
    116                         if isempty(md.runtimename),
     116                        if isempty(md.private.runtimename),
    117117                                error('pfe Download error message: supply runtime name for results to be loaded!');
    118118                        end
    119119
    120120                        %Figure out the  directory where all the files are in:
    121                         directory=[cluster.executionpath '/' md.runtimename '/'];
     121                        directory=[cluster.executionpath '/' md.private.runtimename '/'];
    122122
    123123                        %What packages are we picking up from remote cluster

  • issm/trunk/src/m/classes/clusters/gemini.m

    r9571 r9614  
    5959                         %retrieve parameters
    6060                         modelname=md.name;
    61                          solution_type=md.solution_type;
     61                         solution_type=md.private.solution;
    6262
    6363                         %open file for writing:
    … …  
    8787                         
    8888                         %lauch command, to be executed via ssh
    89                          launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    90                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     89                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     90                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && qsub ' modelname '.queue '];
    9191
    9292                        if ~strcmpi(options.batch,'yes'),
    9393                               
    9494                                %compress the files into one zip.
    95                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     95                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    9696                                if md.dakota_analysis,
    9797                                        compressstring=[compressstring md.name '.qmu.in'];
    … …  
    100100                               
    101101                                disp('uploading input file and queueing script');
    102                                 issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     102                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.private.runtimename '.tar.gz']});
    103103                               
    104104                                disp('launching solution sequence on remote cluster');
    … …  
    115115
    116116                        %some check
    117                         if isempty(md.runtimename),
     117                        if isempty(md.private.runtimename),
    118118                                error('pfe Download error message: supply runtime name for results to be loaded!');
    119119                        end
    120120
    121121                        %Figure out the  directory where all the files are in:
    122                         directory=[cluster.executionpath '/' md.runtimename '/'];
     122                        directory=[cluster.executionpath '/' md.private.runtimename '/'];
    123123
    124124                        %What packages are we picking up from remote cluster

  • issm/trunk/src/m/classes/clusters/generic.m

    r9571 r9614  
    7373                         %retrieve parameters
    7474                         modelname=md.name;
    75                          solution_type=md.solution_type;
     75                         solution_type=md.private.solution;
    7676                         isvalgrind=md.debug.valgrind;
    7777                         isgprof=md.debug.gprof;
    … …  
    116116                         
    117117                         %lauch command, to be executed via ssh
    118                          launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    119                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && source  ' md.name '.queue '];
     118                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     119                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && source  ' md.name '.queue '];
    120120
    121121                        if ~strcmpi(options.batch,'yes'),
    122122                               
    123123                                %compress the files into one zip.
    124                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     124                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    125125                                if md.dakota_analysis,
    126126                                        compressstring=[compressstring md.name '.qmu.in'];
    … …  
    132132                               
    133133                                disp('uploading input file and queueing script');
    134                                 issmscpout(cluster.name,cluster.executionpath,cluster.login,cluster.port,{[md.runtimename '.tar.gz']});
     134                                issmscpout(cluster.name,cluster.executionpath,cluster.login,cluster.port,{[md.private.runtimename '.tar.gz']});
    135135
    136136                                disp('launching solution sequence on remote cluster');
    … …  
    145145
    146146                        %some check
    147                         if isempty(md.runtimename),
     147                        if isempty(md.private.runtimename),
    148148                                error('supply runtime name for results to be loaded!');
    149149                        end
    150150
    151151                        %Figure out the  directory where all the files are in:
    152                         directory=[cluster.executionpath '/' md.runtimename '/'];
     152                        directory=[cluster.executionpath '/' md.private.runtimename '/'];
    153153
    154154                        %What packages are we picking up from remote cluster

  • issm/trunk/src/m/classes/clusters/pfe.m

    r9604 r9614  
    109109                         %retrieve parameters
    110110                         modelname=md.name;
    111                          solution_type=md.solution_type;
     111                         solution_type=md.private.solution;
    112112                         isvalgrind=md.debug.valgrind;
    113113
    … …  
    172172                         %lauch command, to be executed via ssh
    173173                         if ~cluster.interactive,
    174                                 launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    175                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' md.name '.queue '];
    176                         else
    177                                 launchcommand=['cd ' cluster.executionpath '/Interactive' num2str(cluster.interactive) ' && tar -zxf ' md.runtimename '.tar.gz'];
     174                                launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     175                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && qsub ' md.name '.queue '];
     176                        else
     177                                launchcommand=['cd ' cluster.executionpath '/Interactive' num2str(cluster.interactive) ' && tar -zxf ' md.private.runtimename '.tar.gz'];
    178178                        end
    179179
    … …  
    181181                               
    182182                                %compress the files into one zip.
    183                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     183                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    184184                                if md.dakota_analysis,
    185185                                        compressstring=[compressstring md.name '.qmu.in '];
    … …  
    198198                               
    199199                                if ~cluster.bbftp,
    200                                         issmscpout(cluster.name,directory,cluster.login,cluster.port,{[md.runtimename '.tar.gz']});
     200                                        issmscpout(cluster.name,directory,cluster.login,cluster.port,{[md.private.runtimename '.tar.gz']});
    201201                                else
    202                                         issmbbftpout(cluster.name,directory,cluster.login,cluster.port,cluster.numstreams,{[md.runtimename '.tar.gz']});
     202                                        issmbbftpout(cluster.name,directory,cluster.login,cluster.port,cluster.numstreams,{[md.private.runtimename '.tar.gz']});
    203203                                end
    204204                               
    … …  
    215215
    216216                        %some check
    217                         if isempty(md.runtimename),
     217                        if isempty(md.private.runtimename),
    218218                                if ~cluster.interactive,
    219219                                        error('pfe Download error message: supply runtime name for results to be loaded!');
    … …  
    223223                        %Figure out the  directory where all the files are in:
    224224                        if ~cluster.interactive,
    225                                 directory=[cluster.executionpath '/' md.runtimename '/'];
     225                                directory=[cluster.executionpath '/' md.private.runtimename '/'];
    226226                        else
    227227                                directory=[cluster.executionpath '/Interactive' num2str(cluster.interactive) '/'];

  • issm/trunk/src/m/classes/clusters/pollux.m

    r9571 r9614  
    5959                         %retrieve parameters
    6060                         modelname=md.name;
    61                          solution_type=md.solution_type;
     61                         solution_type=md.private.solution;
    6262
    6363                         %open file for writing:
    … …  
    8787                         
    8888                         %lauch command, to be executed via ssh
    89                          launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
    90                                         ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     89                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.private.runtimename ' && mkdir ' md.private.runtimename ...
     90                                        ' && cd ' md.private.runtimename ' && mv ../' md.private.runtimename '.tar.gz ./ && tar -zxf ' md.private.runtimename '.tar.gz  && qsub ' modelname '.queue '];
    9191
    9292                        if ~strcmpi(options.batch,'yes'),
    9393                               
    9494                                %compress the files into one zip.
    95                                 compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     95                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
    9696                                if md.dakota_analysis,
    9797                                        compressstring=[compressstring md.name '.qmu.in'];
    … …  
    100100                               
    101101                                disp('uploading input file and queueing script');
    102                                 issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     102                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.private.runtimename '.tar.gz']});
    103103                               
    104104                                disp('launching solution sequence on remote cluster');
    … …  
    115115
    116116                        %some check
    117                         if isempty(md.runtimename),
     117                        if isempty(md.private.runtimename),
    118118                                error('pfe Download error message: supply runtime name for results to be loaded!');
    119119                        end
    120120
    121121                        %Figure out the  directory where all the files are in:
    122                         directory=[cluster.executionpath '/' md.runtimename '/'];
     122                        directory=[cluster.executionpath '/' md.private.runtimename '/'];
    123123
    124124                        %What packages are we picking up from remote cluster

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

    r9612 r9614  
    1818                 basalforcings   = modelfield('default',0,'marshall',true);
    1919                 friction  = modelfield('default',0,'marshall',true);
     20                 private   = modelfield('default',0,'marshall',false);
    2021
    2122                 %FIXME: all other fields should belong to other classes
    … …  
    2425                 notes           = modelfield('default','','marshall',false);
    2526                 name            = modelfield('default','','marshall',true,'format','String');
    26                  runtimename     = modelfield('default','','marshall',false); %name used when running a parallel job
    2727
    2828                 %Mesh
    29                  bamg                = modelfield('default',struct(),'marshall',false);
    3029                 dim                 = modelfield('default',0,'marshall',true,'format','Integer');
    3130                 numberofelements    = modelfield('default',0,'marshall',true,'format','Integer');
    … …  
    224223                 dummy = modelfield('default',NaN,'marshall',false);
    225224
    226                  %Analysis
    227                  solution_type = modelfield('default','','marshall',false);
    228 
    229225                 %radar power images
    230226                 sarpwr = modelfield('default',NaN,'marshall',false);
    … …  
    549545                         md.basalforcings=basalforcings;
    550546                         md.friction=friction;
     547                         md.private=private;
    551548
    552549                         %Materials parameters

  • issm/trunk/src/m/model/bamg.m

    r9451 r9614  
    253253        %bamg_geometry=processgeometry(bamg_geometry,getfieldvalue(options,'tol',NaN),domain(1));
    254254
    255 elseif isstruct(md.bamg),
    256 
    257         bamg_geometry=bamggeom(md.bamg.geometry); %TEST
     255elseif isstruct(md.private.bamg),
     256
     257        bamg_geometry=bamggeom(md.private.bamg.geometry); %TEST
    258258
    259259else
    … …  
    267267if (~exist(options,'domain') & md.numberofnodes~=0 & md.dim==2),
    268268
    269         if isstruct(md.bamg),
    270                 bamg_mesh=bamgmesh(md.bamg.mesh);
     269        if isstruct(md.private.bamg),
     270                bamg_mesh=bamgmesh(md.private.bamg.mesh);
    271271        else
    272272                bamg_mesh.Vertices=[md.x md.y ones(md.numberofnodes,1)];
    … …  
    314314
    315315% plug results onto model
    316 md.bamg=struct();
    317 md.bamg.mesh=bamgmesh(bamgmesh_out);
    318 md.bamg.geometry=bamggeom(bamggeom_out);
     316md.private.bamg=struct();
     317md.private.bamg.mesh=bamgmesh(bamgmesh_out);
     318md.private.bamg.geometry=bamggeom(bamggeom_out);
    319319md.x=bamgmesh_out.Vertices(:,1);
    320320md.y=bamgmesh_out.Vertices(:,2);
    … …  
    335335md.elementonsurface=ones(md.numberofelements,1);
    336336md.nodeonboundary=zeros(md.numberofnodes,1); md.nodeonboundary(md.segments(:,1:2))=1;
    337 md.elementconnectivity=md.bamg.mesh.ElementConnectivity;
     337md.elementconnectivity=md.private.bamg.mesh.ElementConnectivity;
    338338md.elementconnectivity(find(isnan(md.elementconnectivity)))=0;
    339339

  • issm/trunk/src/m/model/ismodelselfconsistent.m

    r9612 r9614  
    1919% Flaim doesn't need the entire model, so take an early return
    2020%FLAIM {{{1
    21 if (md.solution_type == FlaimSolutionEnum),
     21if (md.private.solution == FlaimSolutionEnum),
    2222        if ~exist(md.flaim.tracks,'file')
    2323                message(['model not consistent: flaim.tracks file ''' md.flaim.tracks ''' must exist.']);
    … …  
    229229
    230230        %OBSERVED VELOCITIES
    231         if md.solution_type==BalancethicknessSolutionEnum
     231        if md.private.solution==BalancethicknessSolutionEnum
    232232                fields={'thickness_obs'};
    233233                checksize(md,fields,[md.numberofnodes 1]);
    … …  
    278278end
    279279
    280 if strcmpi(md.solution_type,'qmu'),
     280if strcmpi(md.private.solution,'qmu'),
    281281        if ~strcmpi(md.cluster.name,'none'),
    282282                if md.waitonlock==0,
    … …  
    289289%Solution specific check
    290290%TRANSIENT {{{1
    291 if (md.solution_type==TransientSolutionEnum),
     291if (md.private.solution==TransientSolutionEnum),
    292292
    293293        if md.dt<=0,
    … …  
    312312%}}}
    313313%STEADYSTATE{{{1
    314 if md.solution_type==SteadystateSolutionEnum,
     314if md.private.solution==SteadystateSolutionEnum,
    315315
    316316        %NDT
    … …  
    326326%}}}
    327327%GROUNDINGLINEMIGRATION2D{{{1
    328 if md.solution_type==GroundinglineMigration2DSolutionEnum,
     328if md.private.solution==GroundinglineMigration2DSolutionEnum,
    329329        if strcmpi(md.cluster.name,'none'),
    330                 message(['model not consistent: ' md.solution_type ' is only implemented in parallel mode !'])
     330                message(['model not consistent: ' md.private.solution ' is only implemented in parallel mode !'])
    331331        end
    332332
    … …  
    336336
    337337        if (md.dim~=2),
    338                 message(['model not consistent: for a ' md.solution_type ' computation, the grounding line module is only implemented in 2d !'])
     338                message(['model not consistent: for a ' md.private.solution ' computation, the grounding line module is only implemented in 2d !'])
    339339        end
    340340
    … …  
    347347%Now check all analyses called for a given solution
    348348%ANALYSESCHECKS {{{1
    349 [analyses,numanalyses]=AnalysisConfiguration(md.solution_type);
     349[analyses,numanalyses]=AnalysisConfiguration(md.private.solution);
    350350for i=1:numanalyses,
    351351        checkforanalysis(md,analyses(i));
    … …  
    480480                        %EXTRUSION
    481481                        if (md.dim==2),
    482                                 if md.solution_type==TransientSolutionEnum,
     482                                if md.private.solution==TransientSolutionEnum,
    483483                                        return;
    484484                                else
    485                                         message(['model not consistent: for a ' EnumToString(md.solution_type) ' computation, the model must be 3d, extrude it first!'])
     485                                        message(['model not consistent: for a ' EnumToString(md.private.solution) ' computation, the model must be 3d, extrude it first!'])
    486486                                end
    487487                        end
    … …  
    528528                        %EXTRUSION
    529529                        if (md.dim==2),
    530                                 if md.solution_type==TransientSolutionEnum,
     530                                if md.private.solution==TransientSolutionEnum,
    531531                                        return;
    532532                                else
    533                                         message(['model not consistent: for a ' EnumToString(md.solution_type) ' computation, the model must be 3d, extrude it first!'])
     533                                        message(['model not consistent: for a ' EnumToString(md.private.solution) ' computation, the model must be 3d, extrude it first!'])
    534534                                end
    535535                        end

  • issm/trunk/src/m/model/loadresultsfromcluster.m

    r9571 r9614  
    99
    1010if nargin==2,
    11         md.runtimename=runtimename;
     11        md.private.runtimename=runtimename;
    1212end
    1313
    … …  
    4343        delete([md.name '.errlog']);
    4444        delete([md.name '.outbin']);
    45         delete([md.runtimename '.tar.gz']);
     45        delete([md.private.runtimename '.tar.gz']);
    4646end
    4747

  • issm/trunk/src/m/model/loadresultsfromdisk.m

    r9571 r9614  
    2323
    2424        %recover solution_type from results
    25         md.solution_type=structure(1).SolutionType;
     25        md.private.solution=structure(1).SolutionType;
    2626
    2727%post processes qmu results if necessary
    2828else
    2929
    30         if isscalar(md.solution_type),
    31                 md.solution_type    =EnumToString(md.solution_type);
     30        if isscalar(md.private.solution),
     31                md.private.solution=EnumToString(md.private.solution);
    3232        end
    3333        md=postqmu(md);

  • issm/trunk/src/m/model/mesh/meshconvert.m

    r9451 r9614  
    2525
    2626% plug results onto model
    27 md.bamg=struct();
    28 md.bamg.mesh=bamgmesh(bamgmesh_out);
    29 md.bamg.geometry=bamggeom(bamggeom_out);
     27md.private.bamg=struct();
     28md.private.bamg.mesh=bamgmesh(bamgmesh_out);
     29md.private.bamg.geometry=bamggeom(bamggeom_out);
    3030md.x=bamgmesh_out.Vertices(:,1);
    3131md.y=bamgmesh_out.Vertices(:,2);

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

    r9571 r9614  
    3232
    3333%recover some fields
    34 md.solution_type=options.solution_type;
     34md.private.solution=options.solution_type;
    3535
    3636%check model consistency
    … …  
    5151
    5252%flaim analysis
    53 if (md.solution_type == FlaimSolutionEnum)
     53if (md.private.solution == FlaimSolutionEnum)
    5454        md=flaim(md,options);
    55         md.solution_type=EnumToString(options.solution_type);
     55        md.private.solution=EnumToString(options.solution_type);
    5656        return;
    5757end
    … …  
    7171
    7272%Launch correct solution sequence
    73 md=issm(md,md.solution_type);
     73md=issm(md,md.private.solution);
    7474
    7575%post processes qmu results if necessary
    … …  
    8282end
    8383
    84 %Check result is consistent
    85 %disp('checking result consistency');
    86 %if ~isresultconsistent(md,options.solution_type),
    87 %       disp('!! results not consistent correct the model !!') %it would be very cruel to put an error, it would kill the computed results (even if not consistent...)
    88 %end
    89 
    9084%convert analysis type to string finally
    91 md.solution_type=EnumToString(options.solution_type);
     85md.private.solution=EnumToString(options.solution_type);

  • issm/trunk/src/m/model/solveparallel.m

    r9571 r9614  
    1414        %First, build a runtime name that is unique, that we will use to create
    1515        %directories, name jobs, etc ...
    16         c=clock; md.runtimename=sprintf('%s-%i-%i-%i-%i-%i-%i-%i',md.name,c(2),c(3),c(1),c(4),c(5),floor(c(6)),feature('GetPid'));
     16        c=clock; md.private.runtimename=sprintf('%s-%i-%i-%i-%i-%i-%i-%i',md.name,c(2),c(3),c(1),c(4),c(5),floor(c(6)),feature('GetPid'));
    1717
    1818        %Now, we need to build the queuing script, used by the cluster to launch the job.

  • issm/trunk/src/m/model/waitonlock.m

    r7984 r9614  
    1414port=md.cluster.port;
    1515timelimit=md.waitonlock;
    16 filename=[executionpath '/' md.runtimename '/' md.name '.lock'];
     16filename=[executionpath '/' md.private.runtimename '/' md.name '.lock'];
    1717
    1818%waitonlock will work if the lock is on the same machine only:
Note: See TracChangeset for help on using the changeset viewer.