Changeset 15767


Ignore:
Timestamp:
08/09/13 09:05:02 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: Prognostic is now Masstransport

Location:
issm/trunk-jpl
Files:
11 added
11 deleted
157 edited
1 copied
8 moved

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/m4/issm_options.m4

    r15764 r15767  
    15231523        AC_MSG_RESULT($HAVE_THERMAL)
    15241524        dnl }}}
    1525         dnl with-prognostic{{{
    1526         AC_ARG_WITH([prognostic],
    1527                 AS_HELP_STRING([--with-prognostic = YES], [compile with prognostic capabilities (default is yes)]),
    1528                 [PROGNOSTIC=$withval],[PROGNOSTIC=yes])
    1529         AC_MSG_CHECKING(for prognostic capability compilation)
    1530 
    1531         if test "x$PROGNOSTIC" = "xyes"; then
     1525        dnl with-masstransport{{{
     1526        AC_ARG_WITH([masstransport],
     1527                AS_HELP_STRING([--with-masstransport = YES], [compile with masstransport capabilities (default is yes)]),
     1528                [MASSTRANSPORT=$withval],[MASSTRANSPORT=yes])
     1529        AC_MSG_CHECKING(for masstransport capability compilation)
     1530
     1531        if test "x$MASSTRANSPORT" = "xyes"; then
    15321532
    15331533                dnl defaults
    1534                 HAVE_PROGNOSTIC=yes
    1535 
    1536                 AC_DEFINE([_HAVE_PROGNOSTIC_],[1],[with prognostic capability])
    1537         else
    1538                 HAVE_PROGNOSTIC=no
    1539         fi
    1540         AM_CONDITIONAL([PROGNOSTIC], [test x$HAVE_PROGNOSTIC = xyes])
    1541         AC_MSG_RESULT($HAVE_PROGNOSTIC)
     1534                HAVE_MASSTRANSPORT=yes
     1535
     1536                AC_DEFINE([_HAVE_MASSTRANSPORT_],[1],[with masstransport capability])
     1537        else
     1538                HAVE_MASSTRANSPORT=no
     1539        fi
     1540        AM_CONDITIONAL([MASSTRANSPORT], [test x$HAVE_MASSTRANSPORT = xyes])
     1541        AC_MSG_RESULT($HAVE_MASSTRANSPORT)
    15421542        dnl }}}
    15431543        dnl with-control{{{

  • issm/trunk-jpl/src/ad/validation/Update/update.m

    r15564 r15767  
    1212md.verbose=verbose('solution',true);
    1313
    14 md=solve(md,PrognosticSolutionEnum);
     14md=solve(md,MasstransportSolutionEnum);
    1515
    16 thickness=md.results.PrognosticSolution.Thickness;
     16thickness=md.results.MasstransportSolution.Thickness;
    1717save ../Validation/Archive.mat thickness;

  • issm/trunk-jpl/src/ad/validation/Validation/validation.m

    r10333 r15767  
    2222
    2323        s=load('Archive.mat'); h0=s.thickness;
    24         h=md.results.PrognosticSolution.Thickness;
     24        h=md.results.MasstransportSolution.Thickness;
    2525        error_diff=full(max(abs(h-h0))/(max(abs(h0))+eps));
    2626        if (error_diff>tolerance);

  • issm/trunk-jpl/src/c/Makefile.am

    r15764 r15767  
    366366steadystate_sources = ./analyses/steadystate_core.cpp
    367367#}}}
    368 #Prognostic sources  {{{
    369 prognostic_sources = ./modules/ModelProcessorx/Prognostic/UpdateElementsPrognostic.cpp\
    370                                               ./modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp\
    371                                               ./modules/ModelProcessorx/Prognostic/CreateConstraintsPrognostic.cpp\
    372                                               ./modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp\
    373                                                         ./analyses/prognostic_core.cpp
     368#Masstransport sources  {{{
     369masstransport_sources = ./modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp\
     370                                              ./modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp\
     371                                              ./modules/ModelProcessorx/Masstransport/CreateConstraintsMasstransport.cpp\
     372                                              ./modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp\
     373                                                        ./analyses/masstransport_core.cpp
    374374#}}}
    375375#Thermal sources  {{{
    … …  
    870870endif
    871871
    872 if PROGNOSTIC
    873 issm_sources  +=  $(prognostic_sources)
     872if MASSTRANSPORT
     873issm_sources  +=  $(masstransport_sources)
    874874endif
    875875

  • issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp

    r15564 r15767  
    7171                        break;
    7272
    73                 case PrognosticSolutionEnum:
     73                case MasstransportSolutionEnum:
    7474                        numanalyses=1;
    7575                        analyses=xNew<int>(numanalyses);
    76                         analyses[0]=PrognosticAnalysisEnum;
     76                        analyses[0]=MasstransportAnalysisEnum;
    7777                        break;
    7878
    … …  
    118118                        analyses[6]=MeltingAnalysisEnum;
    119119                        analyses[7]=EnthalpyAnalysisEnum;
    120                         analyses[8]=PrognosticAnalysisEnum;
     120                        analyses[8]=MasstransportAnalysisEnum;
    121121                        break;
    122122

  • issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp

    r15339 r15767  
    9393                        #endif
    9494                        break;
    95                 case PrognosticSolutionEnum:
    96                         #ifdef _HAVE_PROGNOSTIC_
    97                         solutioncore=&prognostic_core;
     95                case MasstransportSolutionEnum:
     96                        #ifdef _HAVE_MASSTRANSPORT_
     97                        solutioncore=&masstransport_core;
    9898                        #else
    99                         _error_("ISSM was not compiled with prognostic capabilities. Exiting");
     99                        _error_("ISSM was not compiled with masstransport capabilities. Exiting");
    100100                        #endif
    101101                        break;

  • issm/trunk-jpl/src/c/analyses/analyses.h

    r15055 r15767  
    2828void control_core(FemModel* femmodel);
    2929void controltao_core(FemModel* femmodel);
    30 void prognostic_core(FemModel* femmodel);
     30void masstransport_core(FemModel* femmodel);
    3131void balancethickness_core(FemModel* femmodel);
    3232void slopecompute_core(FemModel* femmodel);

  • issm/trunk-jpl/src/c/analyses/masstransport_core.cpp

    r15764 r15767  
    1 /*!\file: prognostic_core.cpp
    2  * \brief: core of the prognostic solution
     1/*!\file: masstransport_core.cpp
     2 * \brief: core of the masstransport solution
    33 */
    44
    … …  
    1010#include "../solutionsequences/solutionsequences.h"
    1111
    12 void prognostic_core(FemModel* femmodel){
     12void masstransport_core(FemModel* femmodel){
    1313
    1414        /*parameters: */
    … …  
    2020
    2121        /*activate formulation: */
    22         femmodel->SetCurrentConfiguration(PrognosticAnalysisEnum);
     22        femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    2323
    2424        /*recover parameters: */
    … …  
    2828        femmodel->parameters->FindParam(&isdelta18o,SurfaceforcingsIsdelta18oEnum);
    2929        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    30         femmodel->parameters->FindParam(&numoutputs,PrognosticNumRequestedOutputsEnum);
    31         if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,PrognosticRequestedOutputsEnum);
     30        femmodel->parameters->FindParam(&numoutputs,MasstransportNumRequestedOutputsEnum);
     31        if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,MasstransportRequestedOutputsEnum);
    3232
    3333        if(issmbgradients){
    … …  
    5252        }
    5353
    54         if(solution_type==PrognosticSolutionEnum)femmodel->RequestedDependentsx();
     54        if(solution_type==MasstransportSolutionEnum)femmodel->RequestedDependentsx();
    5555
    5656        /*Free ressources:*/

  • issm/trunk-jpl/src/c/analyses/transient_core.cpp

    r15375 r15767  
    2121        /*parameters: */
    2222        IssmDouble starttime,finaltime,dt,yts;
    23         bool   isdiagnostic,isprognostic,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia;
     23        bool   isdiagnostic,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia;
    2424        bool   save_results,dakota_analysis;
    2525        bool   time_adapt=false;
    … …  
    4343        femmodel->parameters->FindParam(&time_adapt,TimesteppingTimeAdaptEnum);
    4444        femmodel->parameters->FindParam(&isdiagnostic,TransientIsdiagnosticEnum);
    45         femmodel->parameters->FindParam(&isprognostic,TransientIsprognosticEnum);
     45        femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum);
    4646        femmodel->parameters->FindParam(&isthermal,TransientIsthermalEnum);
    4747        femmodel->parameters->FindParam(&isgia,TransientIsgiaEnum);
    … …  
    6969                if(isthermal && dim==3){
    7070                        //Update Vertex Position after updating Thickness and Bed
    71                         femmodel->SetCurrentConfiguration(PrognosticAnalysisEnum);
     71                        femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    7272                        femmodel->UpdateVertexPositionsx();
    7373                        InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVxMeshEnum,VxMeshEnum);
    … …  
    126126                }
    127127
    128                 if(isprognostic){
     128                if(ismasstransport){
    129129                        if(VerboseSolution()) _printf0_("   computing new thickness\n");
    130                         prognostic_core(femmodel);
     130                        masstransport_core(femmodel);
    131131                        if(VerboseSolution()) _printf0_("   updating vertices positions\n");
    132132                        femmodel->UpdateVertexPositionsx();

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

    r15757 r15767  
    467467                        return CreateBasalMassMatrix();
    468468                        break;
    469                 case PrognosticAnalysisEnum:
    470                         return CreateKMatrixPrognostic();
     469                case MasstransportAnalysisEnum:
     470                        return CreateKMatrixMasstransport();
    471471                        break;
    472472                #ifdef _HAVE_BALANCED_
    … …  
    502502}
    503503/*}}}*/
    504 /*FUNCTION Penta::CreateKMatrixPrognostic {{{*/
    505 ElementMatrix* Penta::CreateKMatrixPrognostic(void){
     504/*FUNCTION Penta::CreateKMatrixMasstransport {{{*/
     505ElementMatrix* Penta::CreateKMatrixMasstransport(void){
    506506
    507507        if (!IsOnBed()) return NULL;
    … …  
    512512
    513513        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    514         ElementMatrix* Ke=tria->CreateKMatrixPrognostic();
     514        ElementMatrix* Ke=tria->CreateKMatrixMasstransport();
    515515        delete tria->material; delete tria;
    516516
    … …  
    663663                        return CreatePVectorSlope();
    664664                        break;
    665                 case PrognosticAnalysisEnum:
    666                         return CreatePVectorPrognostic();
     665                case MasstransportAnalysisEnum:
     666                        return CreatePVectorMasstransport();
    667667                        break;
    668668                #ifdef _HAVE_BALANCED_
    … …  
    687687}
    688688/*}}}*/
    689 /*FUNCTION Penta::CreatePVectorPrognostic {{{*/
    690 ElementVector* Penta::CreatePVectorPrognostic(void){
     689/*FUNCTION Penta::CreatePVectorMasstransport {{{*/
     690ElementVector* Penta::CreatePVectorMasstransport(void){
    691691
    692692        if (!IsOnBed()) return NULL;
    … …  
    698698        /*Call Tria function*/
    699699        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    700         ElementVector* pe=tria->CreatePVectorPrognostic();
     700        ElementVector* pe=tria->CreatePVectorMasstransport();
    701701        delete tria->material; delete tria;
    702702
    … …  
    22602260                InputUpdateFromSolutionOneDofCollapsed(solution,SurfaceSlopeYEnum);
    22612261                break;
    2262         case PrognosticAnalysisEnum:
    2263                 InputUpdateFromSolutionPrognostic(solution);
     2262        case MasstransportAnalysisEnum:
     2263                InputUpdateFromSolutionMasstransport(solution);
    22642264                break;
    22652265        #ifdef _HAVE_BALANCED_
    … …  
    22812281}
    22822282/*}}}*/
    2283 /*FUNCTION Penta::InputUpdateFromSolutionPrognostic{{{*/
    2284 void  Penta::InputUpdateFromSolutionPrognostic(IssmDouble* solution){
     2283/*FUNCTION Penta::InputUpdateFromSolutionMasstransport{{{*/
     2284void  Penta::InputUpdateFromSolutionMasstransport(IssmDouble* solution){
    22852285
    22862286        const int  numdof   = NDOF1*NUMVERTICES;
    … …  
    23052305
    23062306        /*Use the dof list to index into the solution vector and extrude it */
    2307         this->parameters->FindParam(&minthickness,PrognosticMinThicknessEnum);
     2307        this->parameters->FindParam(&minthickness,MasstransportMinThicknessEnum);
    23082308        for(i=0;i<numdof2d;i++){
    23092309                newthickness[i]=solution[doflist[i]];
    … …  
    23192319        GetInputListOnVertices(&oldthickness[0],ThicknessEnum);
    23202320
    2321         /*Fing PrognosticHydrostaticAdjustment to figure out how to update the geometry:*/
    2322         this->parameters->FindParam(&hydroadjustment,PrognosticHydrostaticAdjustmentEnum);
     2321        /*Fing MasstransportHydrostaticAdjustment to figure out how to update the geometry:*/
     2322        this->parameters->FindParam(&hydroadjustment,MasstransportHydrostaticAdjustmentEnum);
    23232323
    23242324        /*recover material parameters: */

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r15749 r15767  
    180180                ElementMatrix* CreateBasalMassMatrix(void);
    181181                ElementMatrix* CreateKMatrix(void);
    182                 ElementMatrix* CreateKMatrixPrognostic(void);
     182                ElementMatrix* CreateKMatrixMasstransport(void);
    183183                ElementVector* CreatePVector(void);
    184                 ElementVector* CreatePVectorPrognostic(void);
     184                ElementVector* CreatePVectorMasstransport(void);
    185185                ElementVector* CreatePVectorSlope(void);
    186186                void           GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble xyz_zero[3][3],IssmDouble xyz_list[6][3],int numpoints);
    … …  
    210210                Penta*         GetBasalElement(void);
    211211                void             InputExtrude(int enum_type,int object_type);
    212                 void           InputUpdateFromSolutionPrognostic(IssmDouble* solutiong);
     212                void           InputUpdateFromSolutionMasstransport(IssmDouble* solutiong);
    213213                void           InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type);
    214214                void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);

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

    r15749 r15767  
    226226                        return CreateMassMatrix();
    227227                        break;
    228                 case PrognosticAnalysisEnum:
    229                         return CreateKMatrixPrognostic();
     228                case MasstransportAnalysisEnum:
     229                        return CreateKMatrixMasstransport();
    230230                        break;
    231231                #ifdef _HAVE_HYDROLOGY_
    … …  
    368368                        return CreatePVectorSlope();
    369369                        break;
    370                 case PrognosticAnalysisEnum:
    371                         return CreatePVectorPrognostic();
     370                case MasstransportAnalysisEnum:
     371                        return CreatePVectorMasstransport();
    372372                        break;
    373373#ifdef _HAVE_HYDROLOGY_
    … …  
    16131613                        InputUpdateFromSolutionOneDof(solution,SurfaceSlopeYEnum);
    16141614                        break;
    1615                 case PrognosticAnalysisEnum:
    1616                         InputUpdateFromSolutionPrognostic(solution);
     1615                case MasstransportAnalysisEnum:
     1616                        InputUpdateFromSolutionMasstransport(solution);
    16171617                        break;
    16181618                default:
    … …  
    16481648}
    16491649/*}}}*/
    1650 /*FUNCTION Tria::InputUpdateFromSolutionPrognostic{{{*/
    1651 void  Tria::InputUpdateFromSolutionPrognostic(IssmDouble* solution){
     1650/*FUNCTION Tria::InputUpdateFromSolutionMasstransport{{{*/
     1651void  Tria::InputUpdateFromSolutionMasstransport(IssmDouble* solution){
    16521652
    16531653        /*Intermediaries*/
    … …  
    16691669
    16701670        /*Use the dof list to index into the solution vector: */
    1671         this->parameters->FindParam(&minthickness,PrognosticMinThicknessEnum);
     1671        this->parameters->FindParam(&minthickness,MasstransportMinThicknessEnum);
    16721672        for(i=0;i<numnodes;i++){
    16731673                newthickness[i]=solution[doflist[i]];
    … …  
    16821682        GetInputListOnNodes(&oldthickness[0],ThicknessEnum);
    16831683
    1684         /*Fing PrognosticHydrostaticAdjustment to figure out how to update the geometry:*/
    1685         this->parameters->FindParam(&hydroadjustment,PrognosticHydrostaticAdjustmentEnum);
     1684        /*Fing MasstransportHydrostaticAdjustment to figure out how to update the geometry:*/
     1685        this->parameters->FindParam(&hydroadjustment,MasstransportHydrostaticAdjustmentEnum);
    16861686        rho_ice=matpar->GetRhoIce();
    16871687        rho_water=matpar->GetRhoWater();
    … …  
    24022402        /*Fetch parameters: */
    24032403        iomodel->Constant(&yts,ConstantsYtsEnum);
    2404         iomodel->Constant(&progstabilization,PrognosticStabilizationEnum);
     2404        iomodel->Constant(&progstabilization,MasstransportStabilizationEnum);
    24052405        iomodel->Constant(&balancestabilization,BalancethicknessStabilizationEnum);
    24062406        iomodel->Constant(&fe_ssa,FlowequationFeSSAEnum);
    … …  
    56245624                                        Ke->values,1);
    56255625
    5626                 GetBPrognostic(B,&xyz_list[0][0], gauss);
    5627                 GetBprimePrognostic(Bprime,&xyz_list[0][0], gauss);
     5626                GetBMasstransport(B,&xyz_list[0][0], gauss);
     5627                GetBprimeMasstransport(Bprime,&xyz_list[0][0], gauss);
    56285628
    56295629                dvxdx=dvx[0];
    … …  
    62786278#endif
    62796279
    6280 #ifdef _HAVE_PROGNOSTIC_
    6281 /*FUNCTION Tria::CreateKMatrixPrognostic {{{*/
    6282 ElementMatrix* Tria::CreateKMatrixPrognostic(void){
     6280#ifdef _HAVE_MASSTRANSPORT_
     6281/*FUNCTION Tria::CreateKMatrixMasstransport {{{*/
     6282ElementMatrix* Tria::CreateKMatrixMasstransport(void){
    62836283
    62846284        switch(GetElementType()){
    62856285                case P1Enum: case P2Enum:
    6286                         return CreateKMatrixPrognostic_CG();
     6286                        return CreateKMatrixMasstransport_CG();
    62876287                case P1DGEnum:
    6288                         return CreateKMatrixPrognostic_DG();
     6288                        return CreateKMatrixMasstransport_DG();
    62896289                default:
    62906290                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
    … …  
    62926292}
    62936293/*}}}*/
    6294 /*FUNCTION Tria::CreateKMatrixPrognostic_CG {{{*/
    6295 ElementMatrix* Tria::CreateKMatrixPrognostic_CG(void){
     6294/*FUNCTION Tria::CreateKMatrixMasstransport_CG {{{*/
     6295ElementMatrix* Tria::CreateKMatrixMasstransport_CG(void){
    62966296
    62976297        /*Intermediaries */
    … …  
    63176317        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    63186318        this->parameters->FindParam(&dim,MeshDimensionEnum);
    6319         this->parameters->FindParam(&stabilization,PrognosticStabilizationEnum);
     6319        this->parameters->FindParam(&stabilization,MasstransportStabilizationEnum);
    63206320        Input* vxaverage_input=NULL;
    63216321        Input* vyaverage_input=NULL;
    … …  
    63516351                                        &Ke->values[0],1);
    63526352
    6353                 GetBPrognostic(B,&xyz_list[0][0],gauss);
    6354                 GetBprimePrognostic(Bprime,&xyz_list[0][0],gauss);
     6353                GetBMasstransport(B,&xyz_list[0][0],gauss);
     6354                GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss);
    63556355
    63566356                dvxdx=dvx[0];
    … …  
    64116411}
    64126412/*}}}*/
    6413 /*FUNCTION Tria::CreateKMatrixPrognostic_DG {{{*/
    6414 ElementMatrix* Tria::CreateKMatrixPrognostic_DG(void){
     6413/*FUNCTION Tria::CreateKMatrixMasstransport_DG {{{*/
     6414ElementMatrix* Tria::CreateKMatrixMasstransport_DG(void){
    64156415
    64166416        /*Intermediaries */
    … …  
    64636463                                        &Ke->values[0],1);
    64646464
    6465                 /*WARNING: B and Bprime are inverted compared to usual prognostic!!!!*/
    6466                 GetBPrognostic(Bprime, &xyz_list[0][0], gauss);
    6467                 GetBprimePrognostic(B, &xyz_list[0][0], gauss);
     6465                /*WARNING: B and Bprime are inverted compared to usual masstransport!!!!*/
     6466                GetBMasstransport(Bprime, &xyz_list[0][0], gauss);
     6467                GetBprimeMasstransport(B, &xyz_list[0][0], gauss);
    64686468
    64696469                D_scalar=-dt*gauss->weight*Jdettria;
    … …  
    64876487}
    64886488/*}}}*/
    6489 /*FUNCTION Tria::CreatePVectorPrognostic{{{*/
    6490 ElementVector* Tria::CreatePVectorPrognostic(void){
     6489/*FUNCTION Tria::CreatePVectorMasstransport{{{*/
     6490ElementVector* Tria::CreatePVectorMasstransport(void){
    64916491
    64926492        switch(GetElementType()){
    64936493                case P1Enum: case P2Enum:
    6494                         return CreatePVectorPrognostic_CG();
     6494                        return CreatePVectorMasstransport_CG();
    64956495                case P1DGEnum:
    6496                         return CreatePVectorPrognostic_DG();
     6496                        return CreatePVectorMasstransport_DG();
    64976497                default:
    64986498                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
    … …  
    65006500}
    65016501/*}}}*/
    6502 /*FUNCTION Tria::CreatePVectorPrognostic_CG {{{*/
    6503 ElementVector* Tria::CreatePVectorPrognostic_CG(void){
     6502/*FUNCTION Tria::CreatePVectorMasstransport_CG {{{*/
     6503ElementVector* Tria::CreatePVectorMasstransport_CG(void){
    65046504
    65056505        /*Intermediaries */
    … …  
    65506550}
    65516551/*}}}*/
    6552 /*FUNCTION Tria::CreatePVectorPrognostic_DG {{{*/
    6553 ElementVector* Tria::CreatePVectorPrognostic_DG(void){
     6552/*FUNCTION Tria::CreatePVectorMasstransport_DG {{{*/
     6553ElementVector* Tria::CreatePVectorMasstransport_DG(void){
    65546554
    65556555        /*Intermediaries */
    … …  
    67966796
    67976797                GetJacobianDeterminant(&Jdettria, &xyz_list[0][0],gauss);
    6798                 GetBPrognostic(B,&xyz_list[0][0],gauss);
    6799                 GetBprimePrognostic(Bprime,&xyz_list[0][0],gauss);
     6798                GetBMasstransport(B,&xyz_list[0][0],gauss);
     6799                GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss);
    68006800
    68016801                vxaverage_input->GetInputValue(&vx,gauss);
    … …  
    68926892
    68936893                GetJacobianDeterminant(&Jdettria, &xyz_list[0][0],gauss);
    6894                 /*WARNING: B and Bprime are inverted compared to usual prognostic!!!!*/
    6895                 GetBPrognostic(Bprime,&xyz_list[0][0],gauss);
    6896                 GetBprimePrognostic(B,&xyz_list[0][0],gauss);
     6894                /*WARNING: B and Bprime are inverted compared to usual masstransport!!!!*/
     6895                GetBMasstransport(Bprime,&xyz_list[0][0],gauss);
     6896                GetBprimeMasstransport(B,&xyz_list[0][0],gauss);
    68976897
    68986898                vx_input->GetInputValue(&vx,gauss);

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r15749 r15767  
    185185                ElementMatrix* CreateKMatrixBalancethickness_CG(void);
    186186                ElementMatrix* CreateKMatrixMelting(void);
    187                 ElementMatrix* CreateKMatrixPrognostic(void);
    188                 ElementMatrix* CreateKMatrixPrognostic_CG(void);
    189                 ElementMatrix* CreateKMatrixPrognostic_DG(void);
     187                ElementMatrix* CreateKMatrixMasstransport(void);
     188                ElementMatrix* CreateKMatrixMasstransport_CG(void);
     189                ElementMatrix* CreateKMatrixMasstransport_DG(void);
    190190                ElementMatrix* CreateMassMatrix(void);
    191191                ElementVector* CreatePVector(void);
    … …  
    193193                ElementVector* CreatePVectorBalancethickness_DG(void);
    194194                ElementVector* CreatePVectorBalancethickness_CG(void);
    195                 ElementVector* CreatePVectorPrognostic(void);
    196                 ElementVector* CreatePVectorPrognostic_CG(void);
    197                 ElementVector* CreatePVectorPrognostic_DG(void);
     195                ElementVector* CreatePVectorMasstransport(void);
     196                ElementVector* CreatePVectorMasstransport_CG(void);
     197                ElementVector* CreatePVectorMasstransport_DG(void);
    198198                ElementVector* CreatePVectorSlope(void);
    199199                IssmDouble     GetArea(void);
    … …  
    216216                void           GetStrainRate2d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussTria* gauss, Input* vx_input, Input* vy_input);
    217217                void             InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type);
    218                 void             InputUpdateFromSolutionPrognostic(IssmDouble* solution);
     218                void             InputUpdateFromSolutionMasstransport(IssmDouble* solution);
    219219                bool             IsInput(int name);
    220220                void             SetClone(int* minranks);

  • issm/trunk-jpl/src/c/classes/Elements/TriaRef.cpp

    r15705 r15767  
    202202}
    203203/*}}}*/
    204 /*FUNCTION TriaRef::GetBPrognostic{{{*/
    205 void TriaRef::GetBPrognostic(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss){
     204/*FUNCTION TriaRef::GetBMasstransport{{{*/
     205void TriaRef::GetBMasstransport(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss){
    206206        /*Compute B  matrix. B=[B1 B2 B3] where Bi is of size 3*NDOF2.
    207207         * For node i, Bi can be expressed in the actual coordinate system
    … …  
    303303}
    304304/*}}}*/
    305 /*FUNCTION TriaRef::GetBprimePrognostic{{{*/
    306 void TriaRef::GetBprimePrognostic(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss){
     305/*FUNCTION TriaRef::GetBprimeMasstransport{{{*/
     306void TriaRef::GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss){
    307307        /*Compute B'  matrix. B'=[B1' B2' B3'] where Bi' is of size 3*NDOF2.
    308308         * For node i, Bi' can be expressed in the actual coordinate system

  • issm/trunk-jpl/src/c/classes/Elements/TriaRef.h

    r15567 r15767  
    2727                void GetBprimeSSA(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss);
    2828                void GetBprimeSSAFS(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss);
    29                 void GetBprimePrognostic(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss);
    30                 void GetBPrognostic(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss);
     29                void GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss);
     30                void GetBMasstransport(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss);
    3131                void GetBHydro(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss);
    3232                void GetBSSAFriction(IssmDouble* L, IssmDouble* xyz_list,GaussTria* gauss);

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

    r15749 r15767  
    254254        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    255255        switch(analysis_type){
    256                 case PrognosticAnalysisEnum:
    257                         Ke=CreateKMatrixPrognostic();
     256                case MasstransportAnalysisEnum:
     257                        Ke=CreateKMatrixMasstransport();
    258258                        break;
    259259                case BalancethicknessAnalysisEnum:
    … …  
    284284
    285285        switch(analysis_type){
    286                 case PrognosticAnalysisEnum:
    287                         pe=CreatePVectorPrognostic();
     286                case MasstransportAnalysisEnum:
     287                        pe=CreatePVectorMasstransport();
    288288                        break;
    289289                case BalancethicknessAnalysisEnum:
    … …  
    422422
    423423/*Numericalflux management*/
    424 /*FUNCTION Numericalflux::CreateKMatrixPrognostic{{{*/
    425 ElementMatrix* Numericalflux::CreateKMatrixPrognostic(void){
     424/*FUNCTION Numericalflux::CreateKMatrixMasstransport{{{*/
     425ElementMatrix* Numericalflux::CreateKMatrixMasstransport(void){
    426426
    427427        int type;
    … …  
    430430        switch(type){
    431431                case InternalEnum:
    432                         return CreateKMatrixPrognosticInternal();
     432                        return CreateKMatrixMasstransportInternal();
    433433                case BoundaryEnum:
    434                         return CreateKMatrixPrognosticBoundary();
     434                        return CreateKMatrixMasstransportBoundary();
    435435                default:
    436436                        _error_("type not supported yet");
    … …  
    438438}
    439439/*}}}*/
    440 /*FUNCTION Numericalflux::CreateKMatrixPrognosticInternal {{{*/
    441 ElementMatrix* Numericalflux::CreateKMatrixPrognosticInternal(void){
     440/*FUNCTION Numericalflux::CreateKMatrixMasstransportInternal {{{*/
     441ElementMatrix* Numericalflux::CreateKMatrixMasstransportInternal(void){
    442442
    443443        /* constants*/
    … …  
    503503}
    504504/*}}}*/
    505 /*FUNCTION Numericalflux::CreateKMatrixPrognosticBoundary {{{*/
    506 ElementMatrix* Numericalflux::CreateKMatrixPrognosticBoundary(void){
     505/*FUNCTION Numericalflux::CreateKMatrixMasstransportBoundary {{{*/
     506ElementMatrix* Numericalflux::CreateKMatrixMasstransportBoundary(void){
    507507
    508508        /* constants*/
    … …  
    758758}
    759759/*}}}*/
    760 /*FUNCTION Numericalflux::CreatePVectorPrognostic{{{*/
    761 ElementVector* Numericalflux::CreatePVectorPrognostic(void){
     760/*FUNCTION Numericalflux::CreatePVectorMasstransport{{{*/
     761ElementVector* Numericalflux::CreatePVectorMasstransport(void){
    762762
    763763        int type;
    … …  
    766766        switch(type){
    767767                case InternalEnum:
    768                         return CreatePVectorPrognosticInternal();
     768                        return CreatePVectorMasstransportInternal();
    769769                case BoundaryEnum:
    770                         return CreatePVectorPrognosticBoundary();
     770                        return CreatePVectorMasstransportBoundary();
    771771                default:
    772772                        _error_("type not supported yet");
    … …  
    774774}
    775775/*}}}*/
    776 /*FUNCTION Numericalflux::CreatePVectorPrognosticInternal{{{*/
    777 ElementVector* Numericalflux::CreatePVectorPrognosticInternal(void){
     776/*FUNCTION Numericalflux::CreatePVectorMasstransportInternal{{{*/
     777ElementVector* Numericalflux::CreatePVectorMasstransportInternal(void){
    778778
    779779        /*Nothing added to PVector*/
    … …  
    782782}
    783783/*}}}*/
    784 /*FUNCTION Numericalflux::CreatePVectorPrognosticBoundary{{{*/
    785 ElementVector* Numericalflux::CreatePVectorPrognosticBoundary(void){
     784/*FUNCTION Numericalflux::CreatePVectorMasstransportBoundary{{{*/
     785ElementVector* Numericalflux::CreatePVectorMasstransportBoundary(void){
    786786
    787787        /* constants*/
    … …  
    806806        Input* vxaverage_input   =tria->inputs->GetInput(VxEnum);                     _assert_(vxaverage_input);
    807807        Input* vyaverage_input   =tria->inputs->GetInput(VyEnum);                     _assert_(vyaverage_input);
    808         Input* spcthickness_input=tria->inputs->GetInput(PrognosticSpcthicknessEnum); _assert_(spcthickness_input);
     808        Input* spcthickness_input=tria->inputs->GetInput(MasstransportSpcthicknessEnum); _assert_(spcthickness_input);
    809809        GetNormal(&normal[0],xyz_list);
    810810

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.h

    r15649 r15767  
    7878                /*Numericalflux management:{{{*/
    7979                void           GetNormal(IssmDouble* normal,IssmDouble xyz_list[4][3]);
    80                 ElementMatrix* CreateKMatrixPrognostic(void);
    81                 ElementMatrix* CreateKMatrixPrognosticInternal(void);
    82                 ElementMatrix* CreateKMatrixPrognosticBoundary(void);
     80                ElementMatrix* CreateKMatrixMasstransport(void);
     81                ElementMatrix* CreateKMatrixMasstransportInternal(void);
     82                ElementMatrix* CreateKMatrixMasstransportBoundary(void);
    8383                ElementMatrix* CreateKMatrixBalancethickness(void);
    8484                ElementMatrix* CreateKMatrixBalancethicknessInternal(void);
    … …  
    8787                ElementMatrix* CreateKMatrixAdjointBalancethicknessInternal(void);
    8888                ElementMatrix* CreateKMatrixAdjointBalancethicknessBoundary(void);
    89                 ElementVector* CreatePVectorPrognostic(void);
    90                 ElementVector* CreatePVectorPrognosticInternal(void);
    91                 ElementVector* CreatePVectorPrognosticBoundary(void);
     89                ElementVector* CreatePVectorMasstransport(void);
     90                ElementVector* CreatePVectorMasstransportInternal(void);
     91                ElementVector* CreatePVectorMasstransportBoundary(void);
    9292                ElementVector* CreatePVectorBalancethickness(void);
    9393                ElementVector* CreatePVectorBalancethicknessInternal(void);

  • issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp

    r15740 r15767  
    176176                        Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax);
    177177                        break;
    178                 case PrognosticAnalysisEnum:
    179                         Ke=PenaltyCreateKMatrixPrognostic(kmax);
     178                case MasstransportAnalysisEnum:
     179                        Ke=PenaltyCreateKMatrixMasstransport(kmax);
    180180                        break;
    181181                default:
    … …  
    391391}
    392392/*}}}*/
    393 /*FUNCTION Penpair::PenaltyCreateKMatrixPrognostic {{{*/
    394 ElementMatrix* Penpair::PenaltyCreateKMatrixPrognostic(IssmDouble kmax){
     393/*FUNCTION Penpair::PenaltyCreateKMatrixMasstransport {{{*/
     394ElementMatrix* Penpair::PenaltyCreateKMatrixMasstransport(IssmDouble kmax){
    395395
    396396        const int numdof=NUMVERTICES*NDOF1;
    … …  
    401401
    402402        /*recover parameters: */
    403         parameters->FindParam(&penalty_factor,PrognosticPenaltyFactorEnum);
     403        parameters->FindParam(&penalty_factor,MasstransportPenaltyFactorEnum);
    404404
    405405        //Create elementary matrix: add penalty to

  • issm/trunk-jpl/src/c/classes/Loads/Penpair.h

    r15567 r15767  
    7070                ElementMatrix* PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax);
    7171                ElementMatrix* PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax);
    72                 ElementMatrix* PenaltyCreateKMatrixPrognostic(IssmDouble kmax);
     72                ElementMatrix* PenaltyCreateKMatrixMasstransport(IssmDouble kmax);
    7373                /*}}}*/
    7474};

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r15749 r15767  
    9292        /*2d solutions in 3d, we need to constrain all the nodes that are not on base*/
    9393        if(
    94                                 analysis_type==PrognosticAnalysisEnum ||
     94                                analysis_type==MasstransportAnalysisEnum ||
    9595                                analysis_type==MeltingAnalysisEnum ||
    9696                                analysis_type==BedSlopeAnalysisEnum ||

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp

    r15564 r15767  
    141141                #endif
    142142
    143                 #ifdef _HAVE_PROGNOSTIC_
    144                 case PrognosticAnalysisEnum:
    145                         CreateNodesPrognostic(pnodes, iomodel);
    146                         CreateConstraintsPrognostic(pconstraints,iomodel);
    147                         CreateLoadsPrognostic(ploads,iomodel);
    148                         UpdateElementsPrognostic(elements,iomodel,analysis_counter,analysis_type);
     143                #ifdef _HAVE_MASSTRANSPORT_
     144                case MasstransportAnalysisEnum:
     145                        CreateNodesMasstransport(pnodes, iomodel);
     146                        CreateConstraintsMasstransport(pconstraints,iomodel);
     147                        CreateLoadsMasstransport(ploads,iomodel);
     148                        UpdateElementsMasstransport(elements,iomodel,analysis_counter,analysis_type);
    149149                        break;
    150150                #endif

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp

    r15564 r15767  
    6565        parameters->AddObject(iomodel->CopyConstantObject(TimesteppingTimeStepEnum));
    6666        parameters->AddObject(iomodel->CopyConstantObject(TimesteppingCflCoefficientEnum));
    67         parameters->AddObject(iomodel->CopyConstantObject(PrognosticHydrostaticAdjustmentEnum));
    68         parameters->AddObject(iomodel->CopyConstantObject(PrognosticStabilizationEnum));
     67        parameters->AddObject(iomodel->CopyConstantObject(MasstransportHydrostaticAdjustmentEnum));
     68        parameters->AddObject(iomodel->CopyConstantObject(MasstransportStabilizationEnum));
    6969        parameters->AddObject(iomodel->CopyConstantObject(DiagnosticPenaltyFactorEnum));
    70         parameters->AddObject(iomodel->CopyConstantObject(PrognosticMinThicknessEnum));
    71         parameters->AddObject(iomodel->CopyConstantObject(PrognosticPenaltyFactorEnum));
     70        parameters->AddObject(iomodel->CopyConstantObject(MasstransportMinThicknessEnum));
     71        parameters->AddObject(iomodel->CopyConstantObject(MasstransportPenaltyFactorEnum));
    7272        parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyFactorEnum));
    7373        parameters->AddObject(iomodel->CopyConstantObject(SettingsLowmemEnum));
    … …  
    9393        parameters->AddObject(iomodel->CopyConstantObject(GroundinglineMigrationEnum));
    9494        parameters->AddObject(iomodel->CopyConstantObject(TransientIsdiagnosticEnum));
    95         parameters->AddObject(iomodel->CopyConstantObject(TransientIsprognosticEnum));
     95        parameters->AddObject(iomodel->CopyConstantObject(TransientIsmasstransportEnum));
    9696        parameters->AddObject(iomodel->CopyConstantObject(TransientIsthermalEnum));
    9797        parameters->AddObject(iomodel->CopyConstantObject(TransientIsgroundinglineEnum));
    … …  
    162162        iomodel->DeleteData(requestedoutputs,SteadystateRequestedOutputsEnum);
    163163
    164         iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,PrognosticRequestedOutputsEnum);
    165         parameters->AddObject(new IntParam(PrognosticNumRequestedOutputsEnum,numoutputs));
    166         if(numoutputs)parameters->AddObject(new IntVecParam(PrognosticRequestedOutputsEnum,requestedoutputs,numoutputs));
    167         iomodel->DeleteData(requestedoutputs,PrognosticRequestedOutputsEnum);
     164        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,MasstransportRequestedOutputsEnum);
     165        parameters->AddObject(new IntParam(MasstransportNumRequestedOutputsEnum,numoutputs));
     166        if(numoutputs)parameters->AddObject(new IntVecParam(MasstransportRequestedOutputsEnum,requestedoutputs,numoutputs));
     167        iomodel->DeleteData(requestedoutputs,MasstransportRequestedOutputsEnum);
    168168
    169169        /*Deal with mass flux segments: {{{*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp

    r15696 r15767  
    100100                        numdofs=1;
    101101                        break;
    102                 case PrognosticAnalysisEnum:
     102                case MasstransportAnalysisEnum:
    103103                        numdofs=1;
    104104                        break;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp

    r15464 r15767  
    117117        }
    118118        xDelete<int>(vertex_pairing);
    119         iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum);
     119        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    120120        for(i=0;i<numvertex_pairing;i++){
    121121                if(my_vertices[vertex_pairing[2*i+0]-1] && !my_vertices[vertex_pairing[2*i+1]-1]){

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateConstraintsMasstransport.cpp

    r15764 r15767  
    55#include "../../IoModelToConstraintsx/IoModelToConstraintsx.h"
    66
    7 void    CreateConstraintsPrognostic(Constraints** pconstraints, IoModel* iomodel){
     7void    CreateConstraintsMasstransport(Constraints** pconstraints, IoModel* iomodel){
    88
    99        /*Fetch parameters: */
    1010        int stabilization;
    11         iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
     11        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    1212
    1313        /*Recover pointer: */
    … …  
    1616        /*Do not add constraints in DG, they are weakly imposed*/
    1717        if(stabilization!=3){
    18                 IoModelToConstraintsx(constraints,iomodel,PrognosticSpcthicknessEnum,PrognosticAnalysisEnum,P1Enum);
     18                IoModelToConstraintsx(constraints,iomodel,MasstransportSpcthicknessEnum,MasstransportAnalysisEnum,P1Enum);
    1919        }
    2020

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp

    r15764 r15767  
    1 /*! \file CreateLoadsPrognostic.c:
     1/*! \file CreateLoadsMasstransport.c:
    22 */
    33
    … …  
    77#include "../ModelProcessorx.h"
    88
    9 void    CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel){
     9void    CreateLoadsMasstransport(Loads** ploads, IoModel* iomodel){
    1010
    1111        /*Intermediaries*/
    … …  
    1717
    1818        /*Fetch parameters: */
    19         iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
     19        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    2020
    2121        /*Recover pointer: */
    … …  
    3939
    4040                        /* Add load */
    41                         loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,i,iomodel,PrognosticAnalysisEnum));
     41                        loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,i,iomodel,MasstransportAnalysisEnum));
    4242                }
    4343
    … …  
    4949        IssmDouble *vertex_pairing=NULL;
    5050        IssmDouble *nodeonbed=NULL;
    51         iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum);
     51        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    5252        iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    5353
    … …  
    7070                                                        iomodel->loadcounter+count+1,
    7171                                                        &penpair_ids[0],
    72                                                         PrognosticAnalysisEnum));
     72                                                        MasstransportAnalysisEnum));
    7373                        count++;
    7474                }
    … …  
    7676
    7777        /*free ressources: */
    78         iomodel->DeleteData(vertex_pairing,PrognosticVertexPairingEnum);
     78        iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum);
    7979        iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    8080

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp

    r15764 r15767  
    11/*
    2  * CreateNodesPrognostic.c:
     2 * CreateNodesMasstransport.c:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    CreateNodesPrognostic(Nodes** pnodes, IoModel* iomodel){
     11void    CreateNodesMasstransport(Nodes** pnodes, IoModel* iomodel){
    1212
    1313        /*Fetch parameters: */
    1414        int  stabilization;
    15         iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
     15        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    1616
    1717        /*Check in 3d*/
    … …  
    2121        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2222        if(stabilization!=3){
    23                 CreateNodes(pnodes,iomodel,PrognosticAnalysisEnum,P1Enum);
     23                CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1Enum);
    2424        }
    2525        else{
    26                 CreateNodes(pnodes,iomodel,PrognosticAnalysisEnum,P1DGEnum);
     26                CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1DGEnum);
    2727        }
    2828        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp

    r15764 r15767  
    11/*
    2  * UpdateElementsPrognostic:
     2 * UpdateElementsMasstransport:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsPrognostic(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
     11void    UpdateElementsMasstransport(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    1313        int    stabilization,finiteelement;
    … …  
    1818
    1919        /*Fetch data needed: */
    20         iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
     20        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    2121        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    2222        iomodel->Constant(&ispdd,SurfaceforcingsIspddEnum);
    … …  
    5252
    5353        if(stabilization==3){
    54                 iomodel->FetchDataToInput(elements,PrognosticSpcthicknessEnum); //for DG, we need the spc in the element
     54                iomodel->FetchDataToInput(elements,MasstransportSpcthicknessEnum); //for DG, we need the spc in the element
    5555        }
    5656

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp

    r15564 r15767  
    1616
    1717        int   i,analysis_type,verbose;
    18         bool  isthermal,isprognostic,isdiagnostic,isgroundingline,isenthalpy;
     18        bool  isthermal,ismasstransport,isdiagnostic,isgroundingline,isenthalpy;
    1919
    2020        /*output: */
    … …  
    3434        iomodel->Constant(&isthermal,TransientIsthermalEnum);
    3535        iomodel->Constant(&isenthalpy,ThermalIsenthalpyEnum);
    36         iomodel->Constant(&isprognostic,TransientIsprognosticEnum);
     36        iomodel->Constant(&ismasstransport,TransientIsmasstransportEnum);
    3737        iomodel->Constant(&isdiagnostic,TransientIsdiagnosticEnum);
    3838        iomodel->Constant(&isgroundingline,TransientIsgroundinglineEnum);
    … …  
    5656                if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;
    5757                if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
    58                 if(solution_type==TransientSolutionEnum && analysis_type==PrognosticAnalysisEnum && isprognostic==false && isgroundingline==false) continue;
     58                if(solution_type==TransientSolutionEnum && analysis_type==MasstransportAnalysisEnum && ismasstransport==false && isgroundingline==false) continue;
    5959                if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticHorizAnalysisEnum && isdiagnostic==false) continue;
    6060                if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticVertAnalysisEnum && isdiagnostic==false) continue;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h

    r15611 r15767  
    9999void UpdateElementsMelting(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    100100
    101 /*prognostic:*/
    102 void CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel);
    103 void CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel);
    104 void CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel);
    105 void UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     101/*masstransport:*/
     102void CreateNodesMasstransport(Nodes** pnodes,IoModel* iomodel);
     103void CreateConstraintsMasstransport(Constraints** pconstraints,IoModel* iomodel);
     104void CreateLoadsMasstransport(Loads** ploads, IoModel* iomodel);
     105void UpdateElementsMasstransport(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    106106
    107107/*balancedthickness:*/

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

    r15749 r15767  
    187187        MeshZEnum,
    188188        MiscellaneousNameEnum, //FIXME: only used by qmu, should not be marshalled (already in queueing script)
    189         PrognosticHydrostaticAdjustmentEnum,
    190         PrognosticMinThicknessEnum,
    191         PrognosticPenaltyFactorEnum,
    192         PrognosticSpcthicknessEnum,
    193         PrognosticStabilizationEnum,
    194         PrognosticVertexPairingEnum,
    195         PrognosticNumRequestedOutputsEnum,
    196         PrognosticRequestedOutputsEnum,
     189        MasstransportHydrostaticAdjustmentEnum,
     190        MasstransportMinThicknessEnum,
     191        MasstransportPenaltyFactorEnum,
     192        MasstransportSpcthicknessEnum,
     193        MasstransportStabilizationEnum,
     194        MasstransportVertexPairingEnum,
     195        MasstransportNumRequestedOutputsEnum,
     196        MasstransportRequestedOutputsEnum,
    197197        QmuIsdakotaEnum,
    198198        MassFluxSegmentsEnum,
    … …  
    256256        TransientIsdiagnosticEnum,
    257257        TransientIsgroundinglineEnum,
    258         TransientIsprognosticEnum,
     258        TransientIsmasstransportEnum,
    259259        TransientIsthermalEnum,
    260260        TransientIsgiaEnum,
    … …  
    293293        HydrologySolutionEnum,
    294294        MeltingAnalysisEnum,
    295         PrognosticAnalysisEnum,
    296         PrognosticSolutionEnum,
     295        MasstransportAnalysisEnum,
     296        MasstransportSolutionEnum,
    297297        SteadystateSolutionEnum,
    298298        SurfaceSlopeAnalysisEnum,

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

    r15749 r15767  
    195195                case MeshZEnum : return "MeshZ";
    196196                case MiscellaneousNameEnum : return "MiscellaneousName";
    197                 case PrognosticHydrostaticAdjustmentEnum : return "PrognosticHydrostaticAdjustment";
    198                 case PrognosticMinThicknessEnum : return "PrognosticMinThickness";
    199                 case PrognosticPenaltyFactorEnum : return "PrognosticPenaltyFactor";
    200                 case PrognosticSpcthicknessEnum : return "PrognosticSpcthickness";
    201                 case PrognosticStabilizationEnum : return "PrognosticStabilization";
    202                 case PrognosticVertexPairingEnum : return "PrognosticVertexPairing";
    203                 case PrognosticNumRequestedOutputsEnum : return "PrognosticNumRequestedOutputs";
    204                 case PrognosticRequestedOutputsEnum : return "PrognosticRequestedOutputs";
     197                case MasstransportHydrostaticAdjustmentEnum : return "MasstransportHydrostaticAdjustment";
     198                case MasstransportMinThicknessEnum : return "MasstransportMinThickness";
     199                case MasstransportPenaltyFactorEnum : return "MasstransportPenaltyFactor";
     200                case MasstransportSpcthicknessEnum : return "MasstransportSpcthickness";
     201                case MasstransportStabilizationEnum : return "MasstransportStabilization";
     202                case MasstransportVertexPairingEnum : return "MasstransportVertexPairing";
     203                case MasstransportNumRequestedOutputsEnum : return "MasstransportNumRequestedOutputs";
     204                case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs";
    205205                case QmuIsdakotaEnum : return "QmuIsdakota";
    206206                case MassFluxSegmentsEnum : return "MassFluxSegments";
    … …  
    264264                case TransientIsdiagnosticEnum : return "TransientIsdiagnostic";
    265265                case TransientIsgroundinglineEnum : return "TransientIsgroundingline";
    266                 case TransientIsprognosticEnum : return "TransientIsprognostic";
     266                case TransientIsmasstransportEnum : return "TransientIsmasstransport";
    267267                case TransientIsthermalEnum : return "TransientIsthermal";
    268268                case TransientIsgiaEnum : return "TransientIsgia";
    … …  
    299299                case HydrologySolutionEnum : return "HydrologySolution";
    300300                case MeltingAnalysisEnum : return "MeltingAnalysis";
    301                 case PrognosticAnalysisEnum : return "PrognosticAnalysis";
    302                 case PrognosticSolutionEnum : return "PrognosticSolution";
     301                case MasstransportAnalysisEnum : return "MasstransportAnalysis";
     302                case MasstransportSolutionEnum : return "MasstransportSolution";
    303303                case SteadystateSolutionEnum : return "SteadystateSolution";
    304304                case SurfaceSlopeAnalysisEnum : return "SurfaceSlopeAnalysis";

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

    r15749 r15767  
    198198              else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
    199199              else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum;
    200               else if (strcmp(name,"PrognosticHydrostaticAdjustment")==0) return PrognosticHydrostaticAdjustmentEnum;
    201               else if (strcmp(name,"PrognosticMinThickness")==0) return PrognosticMinThicknessEnum;
    202               else if (strcmp(name,"PrognosticPenaltyFactor")==0) return PrognosticPenaltyFactorEnum;
    203               else if (strcmp(name,"PrognosticSpcthickness")==0) return PrognosticSpcthicknessEnum;
    204               else if (strcmp(name,"PrognosticStabilization")==0) return PrognosticStabilizationEnum;
    205               else if (strcmp(name,"PrognosticVertexPairing")==0) return PrognosticVertexPairingEnum;
    206               else if (strcmp(name,"PrognosticNumRequestedOutputs")==0) return PrognosticNumRequestedOutputsEnum;
    207               else if (strcmp(name,"PrognosticRequestedOutputs")==0) return PrognosticRequestedOutputsEnum;
     200              else if (strcmp(name,"MasstransportHydrostaticAdjustment")==0) return MasstransportHydrostaticAdjustmentEnum;
     201              else if (strcmp(name,"MasstransportMinThickness")==0) return MasstransportMinThicknessEnum;
     202              else if (strcmp(name,"MasstransportPenaltyFactor")==0) return MasstransportPenaltyFactorEnum;
     203              else if (strcmp(name,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum;
     204              else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum;
     205              else if (strcmp(name,"MasstransportVertexPairing")==0) return MasstransportVertexPairingEnum;
     206              else if (strcmp(name,"MasstransportNumRequestedOutputs")==0) return MasstransportNumRequestedOutputsEnum;
     207              else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum;
    208208              else if (strcmp(name,"QmuIsdakota")==0) return QmuIsdakotaEnum;
    209209              else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum;
    … …  
    270270              else if (strcmp(name,"TransientIsdiagnostic")==0) return TransientIsdiagnosticEnum;
    271271              else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum;
    272               else if (strcmp(name,"TransientIsprognostic")==0) return TransientIsprognosticEnum;
     272              else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    273273              else if (strcmp(name,"TransientIsthermal")==0) return TransientIsthermalEnum;
    274274              else if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum;
    … …  
    305305              else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum;
    306306              else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum;
    307               else if (strcmp(name,"PrognosticAnalysis")==0) return PrognosticAnalysisEnum;
    308               else if (strcmp(name,"PrognosticSolution")==0) return PrognosticSolutionEnum;
     307              else if (strcmp(name,"MasstransportAnalysis")==0) return MasstransportAnalysisEnum;
     308              else if (strcmp(name,"MasstransportSolution")==0) return MasstransportSolutionEnum;
    309309              else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
    310310              else if (strcmp(name,"SurfaceSlopeAnalysis")==0) return SurfaceSlopeAnalysisEnum;

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m

    r15614 r15767  
    4747end
    4848
    49 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     49md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    5050md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    5151

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py

    r15614 r15767  
    4848                print "      no balancethickness.thickening_rate specified: values set as zero"
    4949
    50         md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     50        md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    5151        md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    5252

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m

    r15614 r15767  
    6767end
    6868
    69 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     69md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    7070md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    7171

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py

    r15614 r15767  
    7272                print "      no balancethickness.thickening_rate specified: values set as zero"
    7373
    74         md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     74        md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    7575        md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    7676

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

    r15614 r15767  
    7878end
    7979
    80 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     80md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    8181md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    8282

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

    r15614 r15767  
    7979                print "      no balancethickness.thickening_rate specified: values set as zero"
    8080
    81         md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     81        md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    8282        md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    8383

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

    r15133 r15767  
    2424                function md = checkconsistency(obj,md,solution,analyses) % {{{
    2525
    26                         if ismember(PrognosticAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isprognostic==0),
     26                        if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
    2727                                md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1);
    2828                        end

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

    r15133 r15767  
    3535        def checkconsistency(self,md,solution,analyses):    # {{{
    3636
    37                 if PrognosticAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isprognostic):
     37                if MasstransportAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.ismasstransport):
    3838                        md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1)
    3939

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

    r15143 r15767  
    2929                        md = checkfield(md,'gia.cross_section_shape','numel',[1],'values',[1,2]);
    3030
    31                         %be sure that if we are running a prognostic ice flow model coupled with gia, that thickness forcings
     31                        %be sure that if we are running a masstransport ice flow model coupled with gia, that thickness forcings
    3232                        %are not provided into the future.
    33                         if solution==TransientSolutionEnum() & md.transient.isprognostic & md.transient.isgia,
     33                        if solution==TransientSolutionEnum() & md.transient.ismasstransport & md.transient.isgia,
    3434                                %figure out if thickness is a transient forcing:
    3535                                if size(md.geometry.thickness,1)==md.mesh.numberofvertices+1,
    3636                                        %recover the furthest time "in time":
    3737                                        if(thickness(end,end)~=md.timestepping.start_time),
    38                                                 md = checkmessage(md,['if isprognostic is on, transient thickness forcing'...
     38                                                md = checkmessage(md,['if ismasstransport is on, transient thickness forcing'...
    3939                                                        ' for the gia model should not be provided in the future.'...
    4040                                                        ' Synchronize your start_time to correspond to the most recent transient'...

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

    r15143 r15767  
    4646                md = checkfield(md,'gia.cross_section_shape','numel',[1],'values',[1,2])
    4747
    48                 #be sure that if we are running a prognostic ice flow model coupled with gia, that thickness forcings
     48                #be sure that if we are running a masstransport ice flow model coupled with gia, that thickness forcings
    4949                #are not provided into the future.
    5050

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

    r15343 r15767  
    3636                                end
    3737                        end
    38                         if ismember(PrognosticAnalysisEnum(),analyses),
     38                        if ismember(MasstransportAnalysisEnum(),analyses),
    3939                                md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
    4040                                md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);

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

    r15131 r15767  
    5252                                md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
    5353                                md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
    54                 if PrognosticAnalysisEnum() in analyses:
     54                if MasstransportAnalysisEnum() in analyses:
    5555                        md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
    5656                        md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])

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

    r15764 r15767  
    1 %PROGNOSTIC class definition
     1%MASSTRANSPORT class definition
    22%
    33%   Usage:
    4 %      prognostic=prognostic();
     4%      masstransport=masstransport();
    55
    6 classdef prognostic
     6classdef masstransport
    77        properties (SetAccess=public)
    88                 spcthickness           = NaN;
    … …  
    1515        end
    1616        methods
    17                 function obj = prognostic(varargin) % {{{
     17                function obj = masstransport(varargin) % {{{
    1818                        switch nargin
    1919                                case 0
    … …  
    4040
    4141                        %Early return
    42                         if ~ismember(PrognosticAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isprognostic==0), return; end
     42                        if ~ismember(MasstransportAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.ismasstransport==0), return; end
    4343
    44                         md = checkfield(md,'prognostic.spcthickness','forcing',1);
    45                         md = checkfield(md,'prognostic.hydrostatic_adjustment','values',{'Absolute' 'Incremental'});
    46                         md = checkfield(md,'prognostic.stabilization','values',[0 1 2 3]);
    47                         md = checkfield(md,'prognostic.min_thickness','>',0);
    48                         if ~isempty(md.prognostic.requested_outputs),
    49                                 md = checkfield(md,'prognostic.requested_outputs','size',[NaN 1]);
     44                        md = checkfield(md,'masstransport.spcthickness','forcing',1);
     45                        md = checkfield(md,'masstransport.hydrostatic_adjustment','values',{'Absolute' 'Incremental'});
     46                        md = checkfield(md,'masstransport.stabilization','values',[0 1 2 3]);
     47                        md = checkfield(md,'masstransport.min_thickness','>',0);
     48                        if ~isempty(md.masstransport.requested_outputs),
     49                                md = checkfield(md,'masstransport.requested_outputs','size',[NaN 1]);
    5050                        end
    5151
    5252                end % }}}
    5353                function disp(obj) % {{{
    54                         disp(sprintf('   Prognostic solution parameters:'));
     54                        disp(sprintf('   Masstransport solution parameters:'));
    5555                        fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]');
    5656                        fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]');
    … …  
    6767                        WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1);
    6868                        WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double');
    69                         WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum());
     69                        WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum());
    7070                        WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
    7171                        WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);

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

    r15764 r15767  
    55from WriteData import *
    66
    7 class prognostic(object):
     7class masstransport(object):
    88        """
    9         PROGNOSTIC class definition
     9        MASSTRANSPORT class definition
    1010
    1111           Usage:
    12               prognostic=prognostic();
     12              masstransport=masstransport();
    1313        """
    1414
    … …  
    2727                #}}}
    2828        def __repr__(self): # {{{
    29                 string='   Prognostic solution parameters:'
     29                string='   Masstransport solution parameters:'
    3030                string="%s\n%s"%(string,fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]'))
    3131                string="%s\n%s"%(string,fielddisplay(self,'min_thickness','minimum ice thickness allowed [m]'))
    … …  
    5555
    5656                #Early return
    57                 if (PrognosticAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isprognostic):
     57                if (MasstransportAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.ismasstransport):
    5858                        return md
    5959
    60                 md = checkfield(md,'prognostic.spcthickness','forcing',1)
    61                 md = checkfield(md,'prognostic.hydrostatic_adjustment','values',['Absolute','Incremental'])
    62                 md = checkfield(md,'prognostic.stabilization','values',[0,1,2,3])
    63                 md = checkfield(md,'prognostic.min_thickness','>',0)
    64                 if not md.prognostic.requested_outputs:
    65                         md = checkfield(md,'prognostic.requested_outputs','size',[float('NaN'),1])
     60                md = checkfield(md,'masstransport.spcthickness','forcing',1)
     61                md = checkfield(md,'masstransport.hydrostatic_adjustment','values',['Absolute','Incremental'])
     62                md = checkfield(md,'masstransport.stabilization','values',[0,1,2,3])
     63                md = checkfield(md,'masstransport.min_thickness','>',0)
     64                if not md.masstransport.requested_outputs:
     65                        md = checkfield(md,'masstransport.requested_outputs','size',[float('NaN'),1])
    6666
    6767                return md
    … …  
    7070                WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1)
    7171                WriteData(fid,'object',self,'fieldname','min_thickness','format','Double')
    72                 WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment)[0],'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum())
     72                WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment)[0],'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum())
    7373                WriteData(fid,'object',self,'fieldname','stabilization','format','Integer')
    7474                WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3)

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

    r15433 r15767  
    112112                        %Solution specific checks
    113113                        switch(solution),
    114                                 case PrognosticSolutionEnum(),
    115                                         if md.prognostic.stabilization==3,
     114                                case MasstransportSolutionEnum(),
     115                                        if md.masstransport.stabilization==3,
    116116                                                md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
    117117                                        end
    … …  
    121121                                        end
    122122                                case TransientSolutionEnum(),
    123                                         if md.transient.isprognostic & md.prognostic.stabilization==3,
     123                                        if md.transient.ismasstransport & md.masstransport.stabilization==3,
    124124                                                md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
    125125                                        end

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

    r15433 r15767  
    149149
    150150                #Solution specific checks
    151                 if   solution==PrognosticSolutionEnum():
    152                         if md.prognostic.stabilization==3:
     151                if   solution==MasstransportSolutionEnum():
     152                        if md.masstransport.stabilization==3:
    153153                                md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
    154154                elif solution==BalancethicknessSolutionEnum():
    … …  
    156156                                md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
    157157                elif solution==TransientSolutionEnum():
    158                         if md.transient.isprognostic and md.prognostic.stabilization==3:
     158                        if md.transient.ismasstransport and md.masstransport.stabilization==3:
    159159                                md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
    160160                elif solution==ThermalSolutionEnum():

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

    r15749 r15767  
    3232                groundingline    = 0;
    3333                hydrology        = 0;
    34                 prognostic       = 0;
     34                masstransport       = 0;
    3535                thermal          = 0;
    3636                steadystate      = 0;
    … …  
    9292                                md.hydrology=hydrologyshreve(md.materials);
    9393                        end
    94                         %2013 Juli 25th
     94                        %2013 July 25th
    9595                        if isa(md.diagnostic,'diagnostic'),
    9696                                disp('Recovering old stressbalance class');
    9797                                icefront = md.diagnostic.icefront;
    9898                                md.diagnostic=stressbalance(md.diagnostic);
    99 
    100                                 %Deal with front
    10199                                md.mask.icelevelset=ones(md.mesh.numberofvertices,1);
    102100                                md.mask.icelevelset(icefront(:,1:end-2))=0;
    103101                        end
    104 
    105102                end% }}}
    106103        end
    … …  
    192189                        md.diagnostic.referential=project2d(md,md.diagnostic.referential,md.mesh.numberoflayers);
    193190                        md.diagnostic.loadingforce=project2d(md,md.diagnostic.loadingforce,md.mesh.numberoflayers);
    194                         md.prognostic.spcthickness=project2d(md,md.prognostic.spcthickness,md.mesh.numberoflayers);
     191                        md.masstransport.spcthickness=project2d(md,md.masstransport.spcthickness,md.mesh.numberoflayers);
    195192                        md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.mesh.numberoflayers);
    196193
    … …  
    451448                                md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing(find(md2.diagnostic.vertex_pairing(:,1)),:);
    452449                        end
    453                         if ~isnan(md2.prognostic.vertex_pairing),
    454                                 for i=1:size(md1.prognostic.vertex_pairing,1);
    455                                         md2.prognostic.vertex_pairing(i,:)=Pnode(md1.prognostic.vertex_pairing(i,:));
     450                        if ~isnan(md2.masstransport.vertex_pairing),
     451                                for i=1:size(md1.masstransport.vertex_pairing,1);
     452                                        md2.masstransport.vertex_pairing(i,:)=Pnode(md1.masstransport.vertex_pairing(i,:));
    456453                                end
    457                                 md2.prognostic.vertex_pairing=md2.prognostic.vertex_pairing(find(md2.prognostic.vertex_pairing(:,1)),:);
     454                                md2.masstransport.vertex_pairing=md2.masstransport.vertex_pairing(find(md2.masstransport.vertex_pairing(:,1)),:);
    458455                        end
    459456
    … …  
    718715                        md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node');
    719716                        md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN);
    720                         md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node');
     717                        md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.spcthickness,'type','node');
    721718                        md.balancethickness.spcthickness=project3d(md,'vector',md.balancethickness.spcthickness,'type','node');
    722719                        md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node');
    … …  
    845842                        if isfield(structmd,'time_adapt'), md.timestepping.time_adapt=structmd.time_adapt; end
    846843                        if isfield(structmd,'cfl_coefficient'), md.timestepping.cfl_coefficient=structmd.cfl_coefficient; end
    847                         if isfield(structmd,'spcthickness'), md.prognostic.spcthickness=structmd.spcthickness; end
    848                         if isfield(structmd,'artificial_diffusivity'), md.prognostic.stabilization=structmd.artificial_diffusivity; end
    849                         if isfield(structmd,'hydrostatic_adjustment'), md.prognostic.hydrostatic_adjustment=structmd.hydrostatic_adjustment; end
    850                         if isfield(structmd,'penalties'), md.prognostic.vertex_pairing=structmd.penalties; end
    851                         if isfield(structmd,'penalty_offset'), md.prognostic.penalty_factor=structmd.penalty_offset; end
     844                        if isfield(structmd,'spcthickness'), md.masstransport.spcthickness=structmd.spcthickness; end
     845                        if isfield(structmd,'artificial_diffusivity'), md.masstransport.stabilization=structmd.artificial_diffusivity; end
     846                        if isfield(structmd,'hydrostatic_adjustment'), md.masstransport.hydrostatic_adjustment=structmd.hydrostatic_adjustment; end
     847                        if isfield(structmd,'penalties'), md.masstransport.vertex_pairing=structmd.penalties; end
     848                        if isfield(structmd,'penalty_offset'), md.masstransport.penalty_factor=structmd.penalty_offset; end
    852849                        if isfield(structmd,'B'), md.materials.rheology_B=structmd.B; end
    853850                        if isfield(structmd,'n'), md.materials.rheology_n=structmd.n; end
    … …  
    868865                        if isfield(structmd,'max_steadystate_iterations'), md.steadystate.maxiter=structmd.max_steadystate_iterations; end
    869866                        if isfield(structmd,'isdiagnostic'), md.transient.isdiagnostic=structmd.isdiagnostic; end
    870                         if isfield(structmd,'isprognostic'), md.transient.isprognostic=structmd.isprognostic; end
     867                        if isfield(structmd,'ismasstransport'), md.transient.ismasstransport=structmd.ismasstransport; end
    871868                        if isfield(structmd,'isthermal'), md.transient.isthermal=structmd.isthermal; end
    872869                        if isfield(structmd,'control_analysis'), md.inversion.iscontrol=structmd.control_analysis; end
    … …  
    10251022                        if isfield(structmd,'artificial_diffusivity') & structmd.artificial_diffusivity==2,
    10261023                                        md.thermal.stabilization=2;
    1027                                         md.prognostic.stabilization=1;
     1024                                        md.masstransport.stabilization=1;
    10281025                                        md.balancethickness.stabilization=1;
    10291026                        end
    1030                         if isnumeric(md.prognostic.hydrostatic_adjustment)
    1031                                 if md.prognostic.hydrostatic_adjustment==269,
    1032                                         md.prognostic.hydrostatic_adjustment='Incremental';
     1027                        if isnumeric(md.masstransport.hydrostatic_adjustment)
     1028                                if md.masstransport.hydrostatic_adjustment==269,
     1029                                        md.masstransport.hydrostatic_adjustment='Incremental';
    10331030                                else
    1034                                         md.prognostic.hydrostatic_adjustment='Absolute';
     1031                                        md.masstransport.hydrostatic_adjustment='Absolute';
    10351032                                end
    10361033                        end
    … …  
    10781075                        md.diagnostic       = stressbalance();
    10791076                        md.hydrology        = hydrologyshreve();
    1080                         md.prognostic       = prognostic();
     1077                        md.masstransport       = masstransport();
    10811078                        md.thermal          = thermal();
    10821079                        md.steadystate      = steadystate();
    … …  
    11151112                        disp(sprintf('%19s: %-22s -- %s','groundingline'   ,['[1x1 ' class(obj.groundingline) ']'],'parameters for groundingline solution'));
    11161113                        disp(sprintf('%19s: %-22s -- %s','hydrology'       ,['[1x1 ' class(obj.hydrology) ']'],'parameters for hydrology solution'));
    1117                         disp(sprintf('%19s: %-22s -- %s','prognostic'      ,['[1x1 ' class(obj.prognostic) ']'],'parameters for prognostic solution'));
     1114                        disp(sprintf('%19s: %-22s -- %s','masstransport'      ,['[1x1 ' class(obj.masstransport) ']'],'parameters for masstransport solution'));
    11181115                        disp(sprintf('%19s: %-22s -- %s','thermal'         ,['[1x1 ' class(obj.thermal) ']'],'parameters for thermal solution'));
    11191116                        disp(sprintf('%19s: %-22s -- %s','steadystate'     ,['[1x1 ' class(obj.steadystate) ']'],'parameters for steadystate solution'));

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

    r15749 r15767  
    2424from groundingline import groundingline
    2525from hydrologyshreve import hydrologyshreve
    26 from prognostic import prognostic
     26from masstransport import masstransport
    2727from thermal import thermal
    2828from steadystate import steadystate
    … …  
    7575                self.groundingline    = groundingline()
    7676                self.hydrology        = hydrologyshreve()
    77                 self.prognostic       = prognostic()
     77                self.masstransport       = masstransport()
    7878                self.thermal          = thermal()
    7979                self.steadystate      = steadystate()
    … …  
    114114                        'groundingline',\
    115115                        'hydrology',\
    116                         'prognostic',\
     116                        'masstransport',\
    117117                        'thermal',\
    118118                        'steadystate',\
    … …  
    151151                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("groundingline","[%s,%s]" % ("1x1",obj.groundingline.__class__.__name__),"parameters for groundingline solution"))
    152152                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("hydrology","[%s,%s]" % ("1x1",obj.hydrology.__class__.__name__),"parameters for hydrology solution"))
    153                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("prognostic","[%s,%s]" % ("1x1",obj.prognostic.__class__.__name__),"parameters for prognostic solution"))
     153                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("masstransport","[%s,%s]" % ("1x1",obj.masstransport.__class__.__name__),"parameters for masstransport solution"))
    154154                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("thermal","[%s,%s]" % ("1x1",obj.thermal.__class__.__name__),"parameters for thermal solution"))
    155155                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("steadystate","[%s,%s]" % ("1x1",obj.steadystate.__class__.__name__),"parameters for steadystate solution"))
    … …  
    348348                                md2.diagnostic.vertex_pairing[i,:]=Pnode[md1.diagnostic.vertex_pairing[i,:]]
    349349                        md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing[numpy.nonzero(md2.diagnostic.vertex_pairing[:,0])[0],:]
    350                 if numpy.any(numpy.logical_not(numpy.isnan(md2.prognostic.vertex_pairing))):
    351                         for i in xrange(numpy.size(md1.prognostic.vertex_pairing,axis=0)):
    352                                 md2.prognostic.vertex_pairing[i,:]=Pnode[md1.prognostic.vertex_pairing[i,:]]
    353                         md2.prognostic.vertex_pairing=md2.prognostic.vertex_pairing[numpy.nonzero(md2.prognostic.vertex_pairing[:,0])[0],:]
     350                if numpy.any(numpy.logical_not(numpy.isnan(md2.masstransport.vertex_pairing))):
     351                        for i in xrange(numpy.size(md1.masstransport.vertex_pairing,axis=0)):
     352                                md2.masstransport.vertex_pairing[i,:]=Pnode[md1.masstransport.vertex_pairing[i,:]]
     353                        md2.masstransport.vertex_pairing=md2.masstransport.vertex_pairing[numpy.nonzero(md2.masstransport.vertex_pairing[:,0])[0],:]
    354354
    355355                #recreate segments
    … …  
    612612                md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node')
    613613                md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',float('NaN'))
    614                 md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node')
     614                md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.spcthickness,'type','node')
    615615                md.balancethickness.spcthickness=project3d(md,'vector',md.balancethickness.spcthickness,'type','node')
    616616                md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node')

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

    r13043 r15767  
    4747                         md.diagnostic       = diagnostic();
    4848                         md.hydrology        = hydrology();
    49                          md.prognostic       = prognostic();
     49                         md.masstransport       = masstransport();
    5050                         md.thermal          = thermal();
    5151                         md.steadystate      = steadystate();

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

    r13730 r15767  
    214214                        %      obj=solve(obj,varargin)
    215215                        %      where varargin is a lit of paired arguments.
    216                         %      arguments can be: 'analysis_type': 'diagnostic','thermal','prognostic','transient'
     216                        %      arguments can be: 'analysis_type': 'diagnostic','thermal','masstransport','transient'
    217217                        %
    218218                        %   Examples:

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

    r15764 r15767  
    1 %PROGNOSTIC class definition
     1%MASSTRANSPORT class definition
    22%
    33%   Usage:

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

    r15131 r15767  
    7070                        %Solution specific checks
    7171                        switch(solution),
    72                                 case PrognosticSolutionEnum(),
    73                                         if md.prognostic.stabilization==3,
     72                                case MasstransportSolutionEnum(),
     73                                        if md.masstransport.stabilization==3,
    7474                                                md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes');
    7575                                        end
    7676                                case TransientSolutionEnum(),
    77                                         if md.transient.isprognostic & md.prognostic.stabilization==3,
     77                                        if md.transient.ismasstransport & md.masstransport.stabilization==3,
    7878                                                md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes');
    7979                                        end

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

    r15133 r15767  
    4444                function md = checkconsistency(obj,md,solution,analyses) % {{{
    4545
    46                         if ismember(PrognosticAnalysisEnum(),analyses),
     46                        if ismember(MasstransportAnalysisEnum(),analyses),
    4747                                md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0 1]);
    4848                                md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0 1]);

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

    r15133 r15767  
    7272        def checkconsistency(self,md,solution,analyses):    # {{{
    7373
    74                 if PrognosticAnalysisEnum() in analyses:
     74                if MasstransportAnalysisEnum() in analyses:
    7575                        md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0,1])
    7676                        md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0,1])

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

    r15131 r15767  
    66classdef transient
    77        properties (SetAccess=public)
    8                 isprognostic      = 0;
     8                ismasstransport      = 0;
    99                isdiagnostic      = 0;
    1010                isthermal         = 0;
    … …  
    2424                function obj = setdefaultparameters(obj) % {{{
    2525
    26                         %full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now
    27                         obj.isprognostic=1;
     26                        %full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now
     27                        obj.ismasstransport=1;
    2828                        obj.isdiagnostic=1;
    2929                        obj.isthermal=1;
    … …  
    3737                        if solution~=TransientSolutionEnum(), return; end
    3838
    39                         md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0 1]);
     39                        md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0 1]);
    4040                        md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0 1]);
    4141                        md = checkfield(md,'transient.isthermal','numel',[1],'values',[0 1]);
    … …  
    4848                        disp(sprintf('   transient solution parameters:'));
    4949
    50                         fielddisplay(obj,'isprognostic','indicates if a prognostic solution is used in the transient');
     50                        fielddisplay(obj,'ismasstransport','indicates if a masstransport solution is used in the transient');
    5151                        fielddisplay(obj,'isdiagnostic','indicates if a diagnostic solution is used in the transient');
    5252                        fielddisplay(obj,'isthermal','indicates if a thermal solution is used in the transient');
    … …  
    5757                end % }}}
    5858                function marshall(obj,md,fid) % {{{
    59                         WriteData(fid,'object',obj,'fieldname','isprognostic','format','Boolean');
     59                        WriteData(fid,'object',obj,'fieldname','ismasstransport','format','Boolean');
    6060                        WriteData(fid,'object',obj,'fieldname','isdiagnostic','format','Boolean');
    6161                        WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean');

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

    r15131 r15767  
    1313
    1414        def __init__(self): # {{{
    15                 self.isprognostic      = False
     15                self.ismasstransport      = False
    1616                self.isdiagnostic      = False
    1717                self.isthermal         = False
    … …  
    2626        def __repr__(self): # {{{
    2727                string='   transient solution parameters:'
    28                 string="%s\n%s"%(string,fielddisplay(self,'isprognostic','indicates if a prognostic solution is used in the transient'))
     28                string="%s\n%s"%(string,fielddisplay(self,'ismasstransport','indicates if a masstransport solution is used in the transient'))
    2929                string="%s\n%s"%(string,fielddisplay(self,'isdiagnostic','indicates if a diagnostic solution is used in the transient'))
    3030                string="%s\n%s"%(string,fielddisplay(self,'isthermal','indicates if a thermal solution is used in the transient'))
    … …  
    3636        def setdefaultparameters(self): # {{{
    3737               
    38                 #full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now
    39                 self.isprognostic=True
     38                #full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now
     39                self.ismasstransport=True
    4040                self.isdiagnostic=True
    4141                self.isthermal=True
    … …  
    5151                        return md
    5252
    53                 md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0,1])
     53                md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0,1])
    5454                md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0,1])
    5555                md = checkfield(md,'transient.isthermal','numel',[1],'values',[0,1])
    … …  
    6262        # }}}
    6363        def marshall(self,md,fid):    # {{{
    64                 WriteData(fid,'object',self,'fieldname','isprognostic','format','Boolean')
     64                WriteData(fid,'object',self,'fieldname','ismasstransport','format','Boolean')
    6565                WriteData(fid,'object',self,'fieldname','isdiagnostic','format','Boolean')
    6666                WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean')

  • issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m

    r15564 r15767  
    6161                analyses=[EnthalpyAnalysisEnum()];
    6262
    63         case PrognosticSolutionEnum(),
     63        case MasstransportSolutionEnum(),
    6464                numanalyses=1;
    65                 analyses=[PrognosticAnalysisEnum()];
     65                analyses=[MasstransportAnalysisEnum()];
    6666
    6767        case BalancethicknessSolutionEnum(),
    … …  
    8787        case TransientSolutionEnum(),
    8888                numanalyses=9;
    89                 analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();PrognosticAnalysisEnum()];
     89                analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum()];
    9090
    9191        case FlaimSolutionEnum(),

  • issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py

    r15564 r15767  
    2626                analyses=[EnthalpyAnalysisEnum()]
    2727
    28         elif solutiontype == PrognosticSolutionEnum():
     28        elif solutiontype == MasstransportSolutionEnum():
    2929                numanalyses=1
    30                 analyses=[PrognosticAnalysisEnum()]
     30                analyses=[MasstransportAnalysisEnum()]
    3131
    3232        elif solutiontype == BalancethicknessSolutionEnum():
    … …  
    4848        elif solutiontype == TransientSolutionEnum():
    4949                numanalyses=9
    50                 analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),PrognosticAnalysisEnum()]
     50                analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()]
    5151
    5252        elif solutiontype == FlaimSolutionEnum():

  • issm/trunk-jpl/src/m/enum/EnumDefinitions.py

    r15749 r15767  
    187187def MeshZEnum(): return StringToEnum("MeshZ")[0]
    188188def MiscellaneousNameEnum(): return StringToEnum("MiscellaneousName")[0]
    189 def PrognosticHydrostaticAdjustmentEnum(): return StringToEnum("PrognosticHydrostaticAdjustment")[0]
    190 def PrognosticMinThicknessEnum(): return StringToEnum("PrognosticMinThickness")[0]
    191 def PrognosticPenaltyFactorEnum(): return StringToEnum("PrognosticPenaltyFactor")[0]
    192 def PrognosticSpcthicknessEnum(): return StringToEnum("PrognosticSpcthickness")[0]
    193 def PrognosticStabilizationEnum(): return StringToEnum("PrognosticStabilization")[0]
    194 def PrognosticVertexPairingEnum(): return StringToEnum("PrognosticVertexPairing")[0]
    195 def PrognosticNumRequestedOutputsEnum(): return StringToEnum("PrognosticNumRequestedOutputs")[0]
    196 def PrognosticRequestedOutputsEnum(): return StringToEnum("PrognosticRequestedOutputs")[0]
     189def MasstransportHydrostaticAdjustmentEnum(): return StringToEnum("MasstransportHydrostaticAdjustment")[0]
     190def MasstransportMinThicknessEnum(): return StringToEnum("MasstransportMinThickness")[0]
     191def MasstransportPenaltyFactorEnum(): return StringToEnum("MasstransportPenaltyFactor")[0]
     192def MasstransportSpcthicknessEnum(): return StringToEnum("MasstransportSpcthickness")[0]
     193def MasstransportStabilizationEnum(): return StringToEnum("MasstransportStabilization")[0]
     194def MasstransportVertexPairingEnum(): return StringToEnum("MasstransportVertexPairing")[0]
     195def MasstransportNumRequestedOutputsEnum(): return StringToEnum("MasstransportNumRequestedOutputs")[0]
     196def MasstransportRequestedOutputsEnum(): return StringToEnum("MasstransportRequestedOutputs")[0]
    197197def QmuIsdakotaEnum(): return StringToEnum("QmuIsdakota")[0]
    198198def MassFluxSegmentsEnum(): return StringToEnum("MassFluxSegments")[0]
    … …  
    256256def TransientIsdiagnosticEnum(): return StringToEnum("TransientIsdiagnostic")[0]
    257257def TransientIsgroundinglineEnum(): return StringToEnum("TransientIsgroundingline")[0]
    258 def TransientIsprognosticEnum(): return StringToEnum("TransientIsprognostic")[0]
     258def TransientIsmasstransportEnum(): return StringToEnum("TransientIsmasstransport")[0]
    259259def TransientIsthermalEnum(): return StringToEnum("TransientIsthermal")[0]
    260260def TransientIsgiaEnum(): return StringToEnum("TransientIsgia")[0]
    … …  
    291291def HydrologySolutionEnum(): return StringToEnum("HydrologySolution")[0]
    292292def MeltingAnalysisEnum(): return StringToEnum("MeltingAnalysis")[0]
    293 def PrognosticAnalysisEnum(): return StringToEnum("PrognosticAnalysis")[0]
    294 def PrognosticSolutionEnum(): return StringToEnum("PrognosticSolution")[0]
     293def MasstransportAnalysisEnum(): return StringToEnum("MasstransportAnalysis")[0]
     294def MasstransportSolutionEnum(): return StringToEnum("MasstransportSolution")[0]
    295295def SteadystateSolutionEnum(): return StringToEnum("SteadystateSolution")[0]
    296296def SurfaceSlopeAnalysisEnum(): return StringToEnum("SurfaceSlopeAnalysis")[0]

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

    r13646 r15767  
    4040if ~(strcmpi(analysis_type,'control') |  ...
    4141                strcmpi(analysis_type,'diagnostic') |  ...
    42                 strcmpi(analysis_type,'prognostic') |  ...
     42                strcmpi(analysis_type,'masstransport') |  ...
    4343                strcmpi(analysis_type,'thermal') |  ...
    4444                strcmpi(analysis_type,'parameters') |  ...

  • issm/trunk-jpl/src/m/regional/regionaltransient2d.m

    r13646 r15767  
    118118                md2.diagnostic.spcvy=md2.diagnostic.spcvy*ones(1,size(spcy,2));
    119119                md2.diagnostic.spcvz=md2.diagnostic.spcvz*ones(1,size(spcx,2));
    120                 md2.prognostic.spcthickness=md2.prognostic.spcthickness*ones(1,size(spct,2));
     120                md2.masstransport.spcthickness=md2.masstransport.spcthickness*ones(1,size(spct,2));
    121121                md2.diagnostic.spcvx(find(md2.mesh.vertexonboundary),:)=spcx(find(md2.mesh.vertexonboundary),:);
    122122                md2.diagnostic.spcvy(find(md2.mesh.vertexonboundary),:)=spcy(find(md2.mesh.vertexonboundary),:);
    123123                md2.diagnostic.spcvz(find(md2.mesh.vertexonboundary),:)=0;
    124                 md2.prognostic.spcthickness(find(md2.mesh.vertexonboundary),:)=spct(find(md2.mesh.vertexonboundary),:);
     124                md2.masstransport.spcthickness(find(md2.mesh.vertexonboundary),:)=spct(find(md2.mesh.vertexonboundary),:);
    125125                md2.diagnostic.spcvx=[md2.diagnostic.spcvx; steps];
    126126                md2.diagnostic.spcvy=[md2.diagnostic.spcvy; steps];
    127127                md2.diagnostic.spcvz=[md2.diagnostic.spcvz; steps];
    128                 md2.prognostic.spcthickness=[md2.prognostic.spcthickness; steps];
     128                md2.masstransport.spcthickness=[md2.masstransport.spcthickness; steps];
    129129        end
    130130
    … …  
    149149                md2.diagnostic.spcvy(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    150150                md2.diagnostic.spcvz(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    151                 md2.prognostic.spcthickness(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
     151                md2.masstransport.spcthickness(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    152152        end
    153153

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

    r15339 r15767  
    99%solution_type: check on this option, error out otherwise
    1010solution_type=getfieldvalue(options,'solution_type');
    11 if ~ismember(solution_type,[DiagnosticSolutionEnum(),PrognosticSolutionEnum(),ThermalSolutionEnum(),...
     11if ~ismember(solution_type,[DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),...
    1212                SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),...
    1313                BalancethicknessSolutionEnum(),BalancethicknessSoftSolutionEnum(),BedSlopeSolutionEnum(),...

  • issm/trunk-jpl/src/m/solve/process_solve_options.py

    r14592 r15767  
    1818        #solution_type: check on this option, error out otherwise
    1919        solution_type=options.getfieldvalue('solution_type')
    20         if solution_type not in (DiagnosticSolutionEnum(),PrognosticSolutionEnum(),ThermalSolutionEnum(),\
     20        if solution_type not in (DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),\
    2121                        SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),\
    2222                        BalancethicknessSolutionEnum(),BedSlopeSolutionEnum(),SurfaceSlopeSolutionEnum(),\

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

    r15121 r15767  
    88%   solution types available comprise:
    99%                - DiagnosticSolutionEnum
    10 %                - PrognosticSolutionEnum
     10%                - MasstransportSolutionEnum
    1111%                - ThermalSolutionEnum
    1212%                - SteadystateSolutionEnum

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

    r14874 r15767  
    2222           solution types available comprise:
    2323              - DiagnosticSolutionEnum
    24               - PrognosticSolutionEnum
     24              - MasstransportSolutionEnum
    2525              - ThermalSolutionEnum
    2626              - SteadystateSolutionEnum

  • issm/trunk-jpl/test/NightlyRun/IdToName.m

    r15686 r15767  
    1010        case 103, name='SquareShelfConstrainedDiagHO';
    1111        case 104, name='SquareShelfConstrainedDiagS3d';
    12         case 105, name='SquareShelfConstrainedProg2d';
    13         case 106, name='SquareShelfConstrainedProg2dDG';
    14         case 107, name='SquareShelfConstrainedProg3d';
     12        case 105, name='SquareShelfConstrainedMasstransp2d';
     13        case 106, name='SquareShelfConstrainedMasstransp2dDG';
     14        case 107, name='SquareShelfConstrainedMasstransp3d';
    1515        case 108, name='SquareShelfConstrainedTherStea';
    1616        case 109, name='SquareShelfConstrainedTherTran';
    … …  
    4646        case 217, name='SquareShelfConstrained';
    4747        case 218, name='SquareShelfConstrainedDakotaB';
    48         case 219, name='SquareShelfDiagMHOTiling';
    49         case 220, name='SquareShelfDiagPS3dTiling';
    50         case 221, name='SquareShelfDiagMS3dTiling';
     48        case 219, name='SquareShelfDiagSSAHOTiling';
     49        case 220, name='SquareShelfDiagHOFS3dTiling';
     50        case 221, name='SquareShelfDiagSSAFS3dTiling';
    5151        case 222, name='SquareShelfDiagSSA2dTransientIncrHydro';
    5252        case 223, name='SquareShelfDiagSSA2dTransientIncrNonHydro';
    … …  
    8181        case 307, name='SquareSheetConstrainedDiagHO';
    8282        case 308, name='SquareSheetConstrainedDiagS3d';
    83         case 309, name='SquareSheetConstrainedProg2d';
    84         case 320, name='SquareSheetConstrainedProg2dDG';
    85         case 311, name='SquareSheetConstrainedProg3d';
     83        case 309, name='SquareSheetConstrainedMasstransp2d';
     84        case 320, name='SquareSheetConstrainedMasstransp2dDG';
     85        case 311, name='SquareSheetConstrainedMasstransp3d';
    8686        case 312, name='SquareSheetConstrainedTherStea';
    8787        case 313, name='SquareSheetConstrainedTherTran';
    … …  
    123123        case 417, name='SquareSheetShelfDiadSSA3dDakotaSamp';
    124124        case 418, name='SquareSheetShelfDiadSSA3dDakotaAreaAverage';
    125         case 419, name='SquareSheetShelfDiagMHOTiling';
     125        case 419, name='SquareSheetShelfDiagSSAHOTiling';
    126126        case 420, name='SquareSheetShelfDakotaScaledResponse';
    127         case 421, name='SquareSheetShelfDiagPS3dTiling';
    128         case 422, name='SquareSheetShelfDiagMS3dTiling';
     127        case 421, name='SquareSheetShelfDiagHOFS3dTiling';
     128        case 422, name='SquareSheetShelfDiagSSAFS3dTiling';
    129129        case 423, name='RoundSheetShelfGLMigrationSSA2d';
    130130        case 424, name='SquareSheetShelfGroundingLine2dAgressive';
    … …  
    155155        case 515, name='PigTherTranSUPG';
    156156        case 516, name='PigTherSteaSUPG';
    157         case 601, name='79NorthProg2d';
    158         case 602, name='79NorthProg2dDG';
    159         case 603, name='79NorthProg3d';
     157        case 601, name='79NorthMasstransp2d';
     158        case 602, name='79NorthMasstransp2dDG';
     159        case 603, name='79NorthMasstransp3d';
    160160        case 604, name='79NorthSurfSlop2d';
    161161        case 605, name='79NorthSurfSlop3d';
    … …  
    213213        case 3003, name='SquareShelfConstrainedDiagHOAdolc';
    214214        case 3004, name='SquareShelfConstrainedDiagS3dAdolc';
    215         case 3005, name='SquareShelfConstrainedProg2dAdolc';
    216         case 3006, name='SquareShelfConstrainedProg2dDGAdolc';
    217         case 3007, name='SquareShelfConstrainedProg3dAdolc';
     215        case 3005, name='SquareShelfConstrainedMasstransp2dAdolc';
     216        case 3006, name='SquareShelfConstrainedMasstransp2dDGAdolc';
     217        case 3007, name='SquareShelfConstrainedMasstransp3dAdolc';
    218218        case 3008, name='SquareShelfConstrainedTherSteaAdolc';
    219219        case 3009, name='SquareShelfConstrainedTherTranAdolc';
    220220        case 3010, name='SquareShelfConstrainedTranSSA2dAdolc';
    221         case 3015, name='SquareShelfConstrainedProg2dAdolcForwardDifference';
     221        case 3015, name='SquareShelfConstrainedMasstransp2dAdolcForwardDifference';
    222222        case 3019, name='SquareShelfConstrainedTherTranAdolcReverseVsForward';
    223223

  • issm/trunk-jpl/test/NightlyRun/IdToName.py

    r15686 r15767  
    1414        103 : 'SquareShelfConstrainedDiagHO',
    1515        104 : 'SquareShelfConstrainedDiagS3d',
    16         105 : 'SquareShelfConstrainedProg2d',
    17         106 : 'SquareShelfConstrainedProg2dDG',
    18         107 : 'SquareShelfConstrainedProg3d',
     16        105 : 'SquareShelfConstrainedMasstransp2d',
     17        106 : 'SquareShelfConstrainedMasstransp2dDG',
     18        107 : 'SquareShelfConstrainedMasstransp3d',
    1919        108 : 'SquareShelfConstrainedTherStea',
    2020        109 : 'SquareShelfConstrainedTherTran',
    … …  
    5050        217 : 'SquareShelfConstrained',
    5151        218 : 'SquareShelfConstrainedDakotaB',
    52         219 : 'SquareShelfDiagMHOTiling',
    53         220 : 'SquareShelfDiagPS3dTiling',
    54         221 : 'SquareShelfDiagMS3dTiling',
     52        219 : 'SquareShelfDiagSSAHOTiling',
     53        220 : 'SquareShelfDiagHOFS3dTiling',
     54        221 : 'SquareShelfDiagSSAFS3dTiling',
    5555        222 : 'SquareShelfDiagSSA2dTransientIncrHydro',
    5656        223 : 'SquareShelfDiagSSA2dTransientIncrNonHydro',
    … …  
    8585        307  : 'SquareSheetConstrainedDiagHO',
    8686        308  : 'SquareSheetConstrainedDiagS3d',
    87         309  : 'SquareSheetConstrainedProg2d',
    88         320  : 'SquareSheetConstrainedProg2dDG',
    89         311  : 'SquareSheetConstrainedProg3d',
     87        309  : 'SquareSheetConstrainedMasstransp2d',
     88        320  : 'SquareSheetConstrainedMasstransp2dDG',
     89        311  : 'SquareSheetConstrainedMasstransp3d',
    9090        312  : 'SquareSheetConstrainedTherStea',
    9191        313  : 'SquareSheetConstrainedTherTran',
    … …  
    127127        417  : 'SquareSheetShelfDiadSSA3dDakotaSamp',
    128128        418  : 'SquareSheetShelfDiadSSA3dDakotaAreaAverage',
    129         419  : 'SquareSheetShelfDiagMHOTiling',
     129        419  : 'SquareSheetShelfDiagSSAHOTiling',
    130130        420  : 'SquareSheetShelfDakotaScaledResponse',
    131         421  : 'SquareSheetShelfDiagPS3dTiling',
    132         422  : 'SquareSheetShelfDiagMS3dTiling',
     131        421  : 'SquareSheetShelfDiagHOFS3dTiling',
     132        422  : 'SquareSheetShelfDiagSSAFS3dTiling',
    133133        423  : 'RoundSheetShelfGLMigrationSSA2d',
    134134        424  : 'SquareSheetShelfGroundingLine2dAgressive',
    … …  
    159159        515  : 'PigTherTranSUPG',
    160160        516  : 'PigTherSteaSUPG',
    161         601  : '79NorthProg2d',
    162         602  : '79NorthProg2dDG',
    163         603  : '79NorthProg3d',
     161        601  : '79NorthMasstransp2d',
     162        602  : '79NorthMasstransp2dDG',
     163        603  : '79NorthMasstransp3d',
    164164        604  : '79NorthSurfSlop2d',
    165165        605  : '79NorthSurfSlop3d',
    … …  
    217217        3003 : 'SquareShelfConstrainedDiagHOAdolc',
    218218        3004 : 'SquareShelfConstrainedDiagS3dAdolc',
    219         3005 : 'SquareShelfConstrainedProg2dAdolc',
    220         3006 : 'SquareShelfConstrainedProg2dDGAdolc',
    221         3007 : 'SquareShelfConstrainedProg3dAdolc',
     219        3005 : 'SquareShelfConstrainedMasstransp2dAdolc',
     220        3006 : 'SquareShelfConstrainedMasstransp2dDGAdolc',
     221        3007 : 'SquareShelfConstrainedMasstransp3dAdolc',
    222222        3008 : 'SquareShelfConstrainedTherSteaAdolc',
    223223        3009 : 'SquareShelfConstrainedTherTranAdolc',
    224224        3010 : 'SquareShelfConstrainedTranSSA2dAdolc',
    225         3015 : 'SquareShelfConstrainedProg2dAdolcForwardDifference',
     225        3015 : 'SquareShelfConstrainedMasstransp2dAdolcForwardDifference',
    226226        3019 : 'SquareShelfConstrainedTherTranAdolcReverseVsForward',
    227227        }

  • issm/trunk-jpl/test/NightlyRun/test105.m

    r15565 r15767  
    44md=setflowequation(md,'SSA','all');
    55md.cluster=generic('name',oshostname(),'np',3);
    6 md=solve(md,PrognosticSolutionEnum());
     6md=solve(md,MasstransportSolutionEnum());
    77
    88%Fields and tolerances to track changes
    … …  
    1010field_tolerances={1e-13};
    1111field_values={...
    12         (md.results.PrognosticSolution.Thickness),...
     12        (md.results.MasstransportSolution.Thickness),...
    1313        };

  • issm/trunk-jpl/test/NightlyRun/test105.py

    r15565 r15767  
    1313md=setflowequation(md,'SSA','all')
    1414md.cluster=generic('name',oshostname(),'np',3)
    15 md=solve(md,PrognosticSolutionEnum())
     15md=solve(md,MasstransportSolutionEnum())
    1616
    1717#Fields and tolerances to track changes
    … …  
    1919field_tolerances=[1e-13]
    2020field_values=[\
    21         md.results.PrognosticSolution.Thickness,\
     21        md.results.MasstransportSolution.Thickness,\
    2222        ]

  • issm/trunk-jpl/test/NightlyRun/test106.m

    r15565 r15767  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md.prognostic.stabilization=3;
    8 md.prognostic.spcthickness=md.geometry.thickness;
    9 md=solve(md,PrognosticSolutionEnum());
     7md.masstransport.stabilization=3;
     8md.masstransport.spcthickness=md.geometry.thickness;
     9md=solve(md,MasstransportSolutionEnum());
    1010
    1111%Fields and tolerances to track changes
    … …  
    1313field_tolerances={1e-13};
    1414field_values={...
    15         (md.results.PrognosticSolution.Thickness),...
     15        (md.results.MasstransportSolution.Thickness),...
    1616        };

  • issm/trunk-jpl/test/NightlyRun/test106.py

    r15565 r15767  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md.prognostic.stabilization=3
    18 md.prognostic.spcthickness=md.geometry.thickness
    19 md=solve(md,PrognosticSolutionEnum())
     17md.masstransport.stabilization=3
     18md.masstransport.spcthickness=md.geometry.thickness
     19md=solve(md,MasstransportSolutionEnum())
    2020
    2121#Fields and tolerances to track changes
    … …  
    2323field_tolerances=[1e-13]
    2424field_values=[\
    25         md.results.PrognosticSolution.Thickness,\
     25        md.results.MasstransportSolution.Thickness,\
    2626        ]

  • issm/trunk-jpl/test/NightlyRun/test107.m

    r15565 r15767  
    55md=extrude(md,5,3.);
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,PrognosticSolutionEnum());
     7md=solve(md,MasstransportSolutionEnum());
    88
    99%Fields and tolerances to track changes
    … …  
    1111field_tolerances={1e-13};
    1212field_values={...
    13         (md.results.PrognosticSolution.Thickness),...
     13        (md.results.MasstransportSolution.Thickness),...
    1414        };

  • issm/trunk-jpl/test/NightlyRun/test107.py

    r15565 r15767  
    1414md.extrude(5,3.)
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,PrognosticSolutionEnum())
     16md=solve(md,MasstransportSolutionEnum())
    1717
    1818#Fields and tolerances to track changes
    … …  
    2020field_tolerances=[1e-13]
    2121field_values=[\
    22         md.results.PrognosticSolution.Thickness,\
     22        md.results.MasstransportSolution.Thickness,\
    2323        ]

  • issm/trunk-jpl/test/NightlyRun/test109.m

    r15565 r15767  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.transient.isdiagnostic=0;
    8 md.transient.isprognostic=0;
     8md.transient.ismasstransport=0;
    99md.transient.isthermal=1;
    1010md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test109.py

    r15565 r15767  
    1515md.cluster=generic('name',oshostname(),'np',3)
    1616md.transient.isdiagnostic=False
    17 md.transient.isprognostic=False
     17md.transient.ismasstransport=False
    1818md.transient.isthermal=True
    1919md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test1110.m

    r15565 r15767  
    4747
    4848        md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2];
    49         md.prognostic.vertex_pairing=[posx,posx2;posy,posy2];
     49        md.masstransport.vertex_pairing=[posx,posx2;posy,posy2];
    5050
    5151        md.timestepping.time_step=3.;
    5252        md.timestepping.final_time=300.;
    5353        md.settings.output_frequency=50;
    54         md.prognostic.stabilization=1;
     54        md.masstransport.stabilization=1;
    5555        md.diagnostic.maxiter=1;
    5656       

  • issm/trunk-jpl/test/NightlyRun/test1201.m

    r15565 r15767  
    55
    66for stabilization=1:3;
    7         %The goal is to test the prognostic model
     7        %The goal is to test the masstransport model
    88        md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.);
    99        md=setmask(md,'all','');
    … …  
    1919        %Stabilization
    2020        if stabilization==2,
    21                 md.prognostic.stabilization=0;
     21                md.masstransport.stabilization=0;
    2222        else
    23                 md.prognostic.stabilization=stabilization;
     23                md.masstransport.stabilization=stabilization;
    2424        end
    2525
    … …  
    2727        pos=find(md.mesh.y>199999.9);
    2828        times=0:1:500;
    29         md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times));
    30         md.prognostic.spcthickness(end,:)=times;
    31         md.prognostic.spcthickness(pos,:)=repmat(500.+100.*sin(2.*pi*times/200.),length(pos),1);
     29        md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times));
     30        md.masstransport.spcthickness(end,:)=times;
     31        md.masstransport.spcthickness(pos,:)=repmat(500.+100.*sin(2.*pi*times/200.),length(pos),1);
    3232        if stabilization==3,
    33                 pos=find(isnan(md.prognostic.spcthickness)); md.prognostic.spcthickness(pos)=500.; %No NaN for DG
     33                pos=find(isnan(md.masstransport.spcthickness)); md.masstransport.spcthickness(pos)=500.; %No NaN for DG
    3434        end
    3535

  • issm/trunk-jpl/test/NightlyRun/test1201.py

    r15565 r15767  
    1818
    1919for stabilization in xrange(1,4):
    20         #The goal is to test the prognostic model
     20        #The goal is to test the masstransport model
    2121        md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.)
    2222        md=setmask(md,'all','')
    … …  
    3232        #Stabilization
    3333        if stabilization==2:
    34                 md.prognostic.stabilization=0
     34                md.masstransport.stabilization=0
    3535        else:
    36                 md.prognostic.stabilization=stabilization
     36                md.masstransport.stabilization=stabilization
    3737
    3838        #spc thickness
    3939        pos=numpy.nonzero(md.mesh.y>199999.9)[0]
    4040        times=numpy.arange(0,501)
    41         md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices+1,numpy.size(times)))
    42         md.prognostic.spcthickness[-1,:]=times
    43         md.prognostic.spcthickness[pos,:]=numpy.tile(500.+100.*numpy.sin(2.*numpy.pi*times/200.),(numpy.size(pos),1))
     41        md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices+1,numpy.size(times)))
     42        md.masstransport.spcthickness[-1,:]=times
     43        md.masstransport.spcthickness[pos,:]=numpy.tile(500.+100.*numpy.sin(2.*numpy.pi*times/200.),(numpy.size(pos),1))
    4444        if stabilization==3:
    45                 pos=numpy.nonzero(numpy.isnan(md.prognostic.spcthickness))
    46                 md.prognostic.spcthickness[pos]=500.    #No NaN for DG
     45                pos=numpy.nonzero(numpy.isnan(md.masstransport.spcthickness))
     46                md.masstransport.spcthickness[pos]=500.    #No NaN for DG
    4747
    4848        #solve

  • issm/trunk-jpl/test/NightlyRun/test1202.m

    r15566 r15767  
    1 %Test on the diagnostic model and the prognostic in 2d.
     1%Test on the diagnostic model and the masstransport in 2d.
    22printingflag=false;
    33

  • issm/trunk-jpl/test/NightlyRun/test1202.py

    r15566 r15767  
    1010
    1111"""
    12 Test on the diagnostic model and the prognostic in 2d
     12Test on the diagnostic model and the masstransport in 2d
    1313"""
    1414

  • issm/trunk-jpl/test/NightlyRun/test1203.m

    r15566 r15767  
    1 %Test on the diagnostic model and the prognostic in 2d
     1%Test on the diagnostic model and the masstransport in 2d
    22printingflag=false;
    33

  • issm/trunk-jpl/test/NightlyRun/test1203.py

    r15566 r15767  
    1111
    1212"""
    13 Test on the diagnostic model and the prognostic in 2d
     13Test on the diagnostic model and the masstransport in 2d
    1414"""
    1515

  • issm/trunk-jpl/test/NightlyRun/test1204.m

    r15566 r15767  
    1 %Test on the diagnostic model and the prognostic in 2d
     1%Test on the diagnostic model and the masstransport in 2d
    22printingflag=false;
    33
    … …  
    2323md.timestepping.time_step=1.;
    2424md.timestepping.final_time=5000.;
    25 md.prognostic.stabilization=1;
     25md.masstransport.stabilization=1;
    2626md=solve(md,TransientSolutionEnum());
    2727

  • issm/trunk-jpl/test/NightlyRun/test1204.py

    r15566 r15767  
    1111
    1212"""
    13 Test on the diagnostic model and the prognostic in 2d
     13Test on the diagnostic model and the masstransport in 2d
    1414"""
    1515
    … …  
    3737md.timestepping.time_step=1.
    3838md.timestepping.final_time=5000.
    39 md.prognostic.stabilization=1
     39md.masstransport.stabilization=1
    4040md=solve(md,TransientSolutionEnum())
    4141

  • issm/trunk-jpl/test/NightlyRun/test1208.m

    r15565 r15767  
    2222md.settings.output_frequency=500;
    2323md.timestepping.final_time=30000.;
    24 md.prognostic.stabilization=1;
     24md.masstransport.stabilization=1;
    2525md.thermal.stabilization=1;
    2626

  • issm/trunk-jpl/test/NightlyRun/test1208.py

    r15565 r15767  
    3535md.settings.output_frequency=500
    3636md.timestepping.final_time=30000.
    37 md.prognostic.stabilization=1
     37md.masstransport.stabilization=1
    3838md.thermal.stabilization=1
    3939

  • issm/trunk-jpl/test/NightlyRun/test121.m

    r15565 r15767  
    77md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1);
    88md.transient.isdiagnostic=0;
    9 md.transient.isprognostic=0;
     9md.transient.ismasstransport=0;
    1010md.transient.isthermal=1;
    1111md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test121.py

    r15565 r15767  
    1616md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1))
    1717md.transient.isdiagnostic=False
    18 md.transient.isprognostic=False
     18md.transient.ismasstransport=False
    1919md.transient.isthermal=True
    2020md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test1501.m

    r15565 r15767  
    1717md.basalforcings.melting_rate= smb;
    1818
    19 md=solve(md,PrognosticSolutionEnum());
     19md=solve(md,MasstransportSolutionEnum());
    2020
    2121for i=1:10
    22          md=solve(md,PrognosticSolutionEnum());
    23          md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness);
     22         md=solve(md,MasstransportSolutionEnum());
     23         md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness);
    2424end
    2525

  • issm/trunk-jpl/test/NightlyRun/test1501.py

    r15565 r15767  
    2828md.basalforcings.melting_rate= smb
    2929
    30 md=solve(md,PrognosticSolutionEnum())
     30md=solve(md,MasstransportSolutionEnum())
    3131
    3232for i in xrange(1,11):
    33          md=solve(md,PrognosticSolutionEnum())
    34          md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness)
     33         md=solve(md,MasstransportSolutionEnum())
     34         md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness)
    3535
    3636#Set up transient

  • issm/trunk-jpl/test/NightlyRun/test1502.m

    r15565 r15767  
    1818md.basalforcings.melting_rate= smb;
    1919
    20 md=solve(md,PrognosticSolutionEnum());
     20md=solve(md,MasstransportSolutionEnum());
    2121
    2222for i=1:10
    23          md=solve(md,PrognosticSolutionEnum());
    24          md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness);
     23         md=solve(md,MasstransportSolutionEnum());
     24         md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness);
    2525end
    2626

  • issm/trunk-jpl/test/NightlyRun/test1502.py

    r15565 r15767  
    2929md.basalforcings.melting_rate= smb
    3030
    31 md=solve(md,PrognosticSolutionEnum())
     31md=solve(md,MasstransportSolutionEnum())
    3232
    3333for i in xrange(1,11):
    34          md=solve(md,PrognosticSolutionEnum())
    35          md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness)
     34         md=solve(md,MasstransportSolutionEnum())
     35         md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness)
    3636
    3737#Set up transient

  • issm/trunk-jpl/test/NightlyRun/test207.m

    r15565 r15767  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.transient.isdiagnostic=0;
    8 md.transient.isprognostic=0;
     8md.transient.ismasstransport=0;
    99md.transient.isthermal=1;
    1010md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test207.py

    r15565 r15767  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.transient.isdiagnostic=False
    18 md.transient.isprognostic=False
     18md.transient.ismasstransport=False
    1919md.transient.isthermal=True
    2020md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test222.m

    r15565 r15767  
    44md=setflowequation(md,'SSA','all');
    55md.cluster=generic('name',oshostname(),'np',3);
    6 md.prognostic.hydrostatic_adjustment='Incremental';
     6md.masstransport.hydrostatic_adjustment='Incremental';
    77md=solve(md,TransientSolutionEnum());
    88

  • issm/trunk-jpl/test/NightlyRun/test222.py

    r15565 r15767  
    1313md=setflowequation(md,'SSA','all')
    1414md.cluster=generic('name',oshostname(),'np',3)
    15 md.prognostic.hydrostatic_adjustment='Incremental'
     15md.masstransport.hydrostatic_adjustment='Incremental'
    1616md=solve(md,TransientSolutionEnum())
    1717

  • issm/trunk-jpl/test/NightlyRun/test223.m

    r15565 r15767  
    55md.geometry.bed=md.geometry.bed+50.; md.geometry.surface=md.geometry.surface+50.;
    66md.cluster=generic('name',oshostname(),'np',1);
    7 md.prognostic.hydrostatic_adjustment='Incremental';
     7md.masstransport.hydrostatic_adjustment='Incremental';
    88md=solve(md,TransientSolutionEnum());
    99

  • issm/trunk-jpl/test/NightlyRun/test223.py

    r15565 r15767  
    1515md.geometry.surface=md.geometry.surface+50.
    1616md.cluster=generic('name',oshostname(),'np',1)
    17 md.prognostic.hydrostatic_adjustment='Incremental'
     17md.masstransport.hydrostatic_adjustment='Incremental'
    1818md=solve(md,TransientSolutionEnum())
    1919

  • issm/trunk-jpl/test/NightlyRun/test224.m

    r15565 r15767  
    55md=setflowequation(md,'HO','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md.prognostic.hydrostatic_adjustment='Incremental';
     7md.masstransport.hydrostatic_adjustment='Incremental';
    88md=solve(md,TransientSolutionEnum());
    99

  • issm/trunk-jpl/test/NightlyRun/test224.py

    r15565 r15767  
    1414md=setflowequation(md,'HO','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md.prognostic.hydrostatic_adjustment='Incremental'
     16md.masstransport.hydrostatic_adjustment='Incremental'
    1717md=solve(md,TransientSolutionEnum())
    1818

  • issm/trunk-jpl/test/NightlyRun/test225.m

    r15647 r15767  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md.prognostic.hydrostatic_adjustment='Incremental';
     8md.masstransport.hydrostatic_adjustment='Incremental';
    99md=solve(md,TransientSolutionEnum());
    1010

  • issm/trunk-jpl/test/NightlyRun/test225.py

    r15647 r15767  
    1616md=setflowequation(md,'HO','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md.prognostic.hydrostatic_adjustment='Incremental'
     18md.masstransport.hydrostatic_adjustment='Incremental'
    1919md=solve(md,TransientSolutionEnum())
    2020

  • issm/trunk-jpl/test/NightlyRun/test232.m

    r15565 r15767  
    99md.timestepping.final_time=4;
    1010md.transient.isdiagnostic=0;
    11 md.transient.isprognostic=0;
     11md.transient.ismasstransport=0;
    1212md.transient.isthermal=1;
    1313md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test232.py

    r15565 r15767  
    1919md.timestepping.final_time=4.
    2020md.transient.isdiagnostic=False
    21 md.transient.isprognostic=False
     21md.transient.ismasstransport=False
    2222md.transient.isthermal=True
    2323md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test3005.m

    r15565 r15767  
    77md.toolkits.DefaultAnalysis=issmsolver();
    88md.verbose=verbose('autodiff',true);
    9 md=solve(md,PrognosticSolutionEnum());
     9md=solve(md,MasstransportSolutionEnum());
    1010
    1111%Fields and tolerances to track changes
    … …  
    1313field_tolerances={1e-13};
    1414field_values={...
    15         (md.results.PrognosticSolution.Thickness),...
     15        (md.results.MasstransportSolution.Thickness),...
    1616        };

  • issm/trunk-jpl/test/NightlyRun/test3005.py

    r15565 r15767  
    1515md.toolkits.DefaultAnalysis=issmsolver()
    1616md.autodiff.isautodiff=True
    17 md=solve(md,PrognosticSolutionEnum())
     17md=solve(md,MasstransportSolutionEnum())
    1818
    1919#Fields and tolerances to track changes
    … …  
    2121field_tolerances=[1e-13]
    2222field_values=[\
    23         md.results.PrognosticSolution.Thickness,\
     23        md.results.MasstransportSolution.Thickness,\
    2424        ]

  • issm/trunk-jpl/test/NightlyRun/test3006.m

    r15565 r15767  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',1);
    7 md.prognostic.stabilization=3;
    8 md.prognostic.spcthickness=md.geometry.thickness;
     7md.masstransport.stabilization=3;
     8md.masstransport.spcthickness=md.geometry.thickness;
    99md.autodiff.isautodiff=true;
    1010md.toolkits.DefaultAnalysis=issmsolver();
    1111md.verbose=verbose('autodiff',true);
    12 md=solve(md,PrognosticSolutionEnum());
     12md=solve(md,MasstransportSolutionEnum());
    1313
    1414%Fields and tolerances to track changes
    … …  
    1616field_tolerances={1e-13};
    1717field_values={...
    18         (md.results.PrognosticSolution.Thickness),...
     18        (md.results.MasstransportSolution.Thickness),...
    1919        };

  • issm/trunk-jpl/test/NightlyRun/test3006.py

    r15565 r15767  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',1)
    17 md.prognostic.stabilization=3
    18 md.prognostic.spcthickness=md.geometry.thickness
     17md.masstransport.stabilization=3
     18md.masstransport.spcthickness=md.geometry.thickness
    1919md.toolkits.DefaultAnalysis=issmsolver()
    2020md.autodiff.isautodiff=True
    21 md=solve(md,PrognosticSolutionEnum())
     21md=solve(md,MasstransportSolutionEnum())
    2222
    2323#Fields and tolerances to track changes
    … …  
    2525field_tolerances=[1e-13]
    2626field_values=[\
    27         md.results.PrognosticSolution.Thickness,\
     27        md.results.MasstransportSolution.Thickness,\
    2828        ]

  • issm/trunk-jpl/test/NightlyRun/test3007.m

    r15565 r15767  
    88md.verbose=verbose('autodiff',true);
    99md.toolkits.DefaultAnalysis=issmsolver();
    10 md=solve(md,PrognosticSolutionEnum());
     10md=solve(md,MasstransportSolutionEnum());
    1111
    1212%Fields and tolerances to track changes
    … …  
    1414field_tolerances={1e-13};
    1515field_values={...
    16         (md.results.PrognosticSolution.Thickness),...
     16        (md.results.MasstransportSolution.Thickness),...
    1717        };

  • issm/trunk-jpl/test/NightlyRun/test3007.py

    r15565 r15767  
    1616md.toolkits.DefaultAnalysis=issmsolver()
    1717md.autodiff.isautodiff=True
    18 md=solve(md,PrognosticSolutionEnum())
     18md=solve(md,MasstransportSolutionEnum())
    1919
    2020#Fields and tolerances to track changes
    … …  
    2222field_tolerances=[1e-13]
    2323field_values=[\
    24         md.results.PrognosticSolution.Thickness,\
     24        md.results.MasstransportSolution.Thickness,\
    2525        ]

  • issm/trunk-jpl/test/NightlyRun/test3009.m

    r15565 r15767  
    66md.cluster=generic('name',oshostname(),'np',1);
    77md.transient.isdiagnostic=0;
    8 md.transient.isprognostic=0;
     8md.transient.ismasstransport=0;
    99md.transient.isthermal=1;
    1010md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test3009.py

    r15565 r15767  
    1515md.cluster=generic('name',oshostname(),'np',1)
    1616md.transient.isdiagnostic=False
    17 md.transient.isprognostic=False
     17md.transient.ismasstransport=False
    1818md.transient.isthermal=True
    1919md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test3015.m

    r15565 r15767  
    88md=setflowequation(md,'SSA','all');
    99md.cluster=generic('name',oshostname(),'np',1);
    10 md.prognostic.requested_outputs=IceVolumeEnum();
     10md.masstransport.requested_outputs=IceVolumeEnum();
    1111md.verbose=verbose('autodiff',true);
    1212md.toolkits.DefaultAnalysis=issmsolver();
    … …  
    4242md=SetIceShelfBC(md);
    4343
    44 md=solve(md,PrognosticSolutionEnum());
    45 V0=md.results.PrognosticSolution.IceVolume;
     44md=solve(md,MasstransportSolutionEnum());
     45V0=md.results.MasstransportSolution.IceVolume;
    4646
    4747%backward
    … …  
    5353md=SetIceShelfBC(md);
    5454
    55 md=solve(md,PrognosticSolutionEnum());
    56 V2=md.results.PrognosticSolution.IceVolume;
     55md=solve(md,MasstransportSolutionEnum());
     56V2=md.results.MasstransportSolution.IceVolume;
    5757
    5858%compute resulting derivative
    … …  
    6767md=SetIceShelfBC(md);
    6868
    69 md=solve(md,PrognosticSolutionEnum());
     69md=solve(md,MasstransportSolutionEnum());
    7070%retrieve directly
    71 dVdh_ad=md.results.PrognosticSolution.AutodiffJacobian;
     71dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian;
    7272
    7373disp(sprintf('dV/dh: analytical:  %16.16g\n       using adolc:  %16.16g\n',dVdh_an,dVdh_ad));

  • issm/trunk-jpl/test/NightlyRun/test3015.py

    r15565 r15767  
    2222md=setflowequation(md,'SSA','all')
    2323md.cluster=generic('name',oshostname(),'np',3)
    24 md.prognostic.requested_outputs=IceVolumeEnum()
     24md.masstransport.requested_outputs=IceVolumeEnum()
    2525md.verbose=verbose('autodiff',True)
    2626
    … …  
    5555md=SetIceShelfBC(md)
    5656
    57 md=solve(md,PrognosticSolutionEnum())
    58 V0=md.results.PrognosticSolution.IceVolume
     57md=solve(md,MasstransportSolutionEnum())
     58V0=md.results.MasstransportSolution.IceVolume
    5959
    6060#backward
    … …  
    6666md=SetIceShelfBC(md)
    6767
    68 md=solve(md,PrognosticSolutionEnum())
    69 V2=md.results.PrognosticSolution.IceVolume
     68md=solve(md,MasstransportSolutionEnum())
     69V2=md.results.MasstransportSolution.IceVolume
    7070
    7171#compute resulting derivative
    … …  
    8080md=SetIceShelfBC(md)
    8181
    82 md=solve(md,PrognosticSolutionEnum())
     82md=solve(md,MasstransportSolutionEnum())
    8383#retrieve directly
    84 dVdh_ad=md.results.PrognosticSolution.AutodiffJacobian
     84dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian
    8585
    8686print "dV/dh: analytical:  #16.16g\n       using adolc:  #16.16g\n" % (dVdh_an,dVdh_ad)

  • issm/trunk-jpl/test/NightlyRun/test309.m

    r15565 r15767  
    44md=setflowequation(md,'SSA','all');
    55md.cluster=generic('name',oshostname(),'np',3);
    6 md=solve(md,PrognosticSolutionEnum());
     6md=solve(md,MasstransportSolutionEnum());
    77
    88%Fields and tolerances to track changes
    … …  
    1010field_tolerances={1e-13};
    1111field_values={...
    12         (md.results.PrognosticSolution.Thickness),...
     12        (md.results.MasstransportSolution.Thickness),...
    1313        };

  • issm/trunk-jpl/test/NightlyRun/test309.py

    r15565 r15767  
    1313md=setflowequation(md,'SSA','all')
    1414md.cluster=generic('name',oshostname(),'np',3)
    15 md=solve(md,PrognosticSolutionEnum())
     15md=solve(md,MasstransportSolutionEnum())
    1616
    1717#Fields and tolerances to track changes
    … …  
    1919field_tolerances=[1e-13]
    2020field_values=[\
    21         md.results.PrognosticSolution.Thickness,\
     21        md.results.MasstransportSolution.Thickness,\
    2222        ]

  • issm/trunk-jpl/test/NightlyRun/test310.m

    r15565 r15767  
    44md=parameterize(md,'../Par/SquareSheetConstrained.par');
    55md=setflowequation(md,'SSA','all');
    6 md.prognostic.stabilization=3;
    7 md.prognostic.spcthickness=md.geometry.thickness;
     6md.masstransport.stabilization=3;
     7md.masstransport.spcthickness=md.geometry.thickness;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,PrognosticSolutionEnum());
     9md=solve(md,MasstransportSolutionEnum());
    1010
    1111%Fields and tolerances to track changes
    … …  
    1313field_tolerances={1e-13};
    1414field_values={...
    15         (md.results.PrognosticSolution.Thickness),...
     15        (md.results.MasstransportSolution.Thickness),...
    1616        };

  • issm/trunk-jpl/test/NightlyRun/test310.py

    r15565 r15767  
    1414md=parameterize(md,'../Par/SquareSheetConstrained.py')
    1515md=setflowequation(md,'SSA','all')
    16 md.prognostic.stabilization=3
    17 md.prognostic.spcthickness=md.geometry.thickness
     16md.masstransport.stabilization=3
     17md.masstransport.spcthickness=md.geometry.thickness
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,PrognosticSolutionEnum())
     19md=solve(md,MasstransportSolutionEnum())
    2020
    2121#Fields and tolerances to track changes
    … …  
    2323field_tolerances=[1e-13]
    2424field_values=[\
    25         md.results.PrognosticSolution.Thickness,\
     25        md.results.MasstransportSolution.Thickness,\
    2626        ]

  • issm/trunk-jpl/test/NightlyRun/test311.m

    r15565 r15767  
    55md=extrude(md,5,0.5);
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,PrognosticSolutionEnum());
     7md=solve(md,MasstransportSolutionEnum());
    88
    99%Fields and tolerances to track changes
    … …  
    1111field_tolerances={1e-13};
    1212field_values={...
    13         (md.results.PrognosticSolution.Thickness),...
     13        (md.results.MasstransportSolution.Thickness),...
    1414        };

  • issm/trunk-jpl/test/NightlyRun/test311.py

    r15565 r15767  
    1414md.extrude(5,0.5)
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,PrognosticSolutionEnum())
     16md=solve(md,MasstransportSolutionEnum())
    1717
    1818#Fields and tolerances to track changes
    … …  
    2020field_tolerances=[1e-13]
    2121field_values=[\
    22         md.results.PrognosticSolution.Thickness,\
     22        md.results.MasstransportSolution.Thickness,\
    2323        ]

  • issm/trunk-jpl/test/NightlyRun/test313.m

    r15565 r15767  
    77md.verbose=verbose('convergence',true,'solution',true);
    88md.transient.isdiagnostic=0;
    9 md.transient.isprognostic=0;
     9md.transient.ismasstransport=0;
    1010md.transient.isthermal=1;
    1111md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test313.py

    r15565 r15767  
    1616md.verbose=verbose('convergence',True,'solution',True)
    1717md.transient.isdiagnostic=False
    18 md.transient.isprognostic=False
     18md.transient.ismasstransport=False
    1919md.transient.isthermal=True
    2020md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test326.m

    r15565 r15767  
    77md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1);
    88md.transient.isdiagnostic=0;
    9 md.transient.isprognostic=0;
     9md.transient.ismasstransport=0;
    1010md.transient.isthermal=1;
    1111md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test326.py

    r15565 r15767  
    1717md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1))
    1818md.transient.isdiagnostic=False
    19 md.transient.isprognostic=False
     19md.transient.ismasstransport=False
    2020md.transient.isthermal=True
    2121md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test407.m

    r15565 r15767  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.transient.isdiagnostic=0;
    8 md.transient.isprognostic=0;
     8md.transient.ismasstransport=0;
    99md.transient.isthermal=1;
    1010md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test407.py

    r15565 r15767  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.transient.isdiagnostic=False
    18 md.transient.isprognostic=False
     18md.transient.ismasstransport=False
    1919md.transient.isthermal=True
    2020md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test423.m

    r15565 r15767  
    1919
    2020md.transient.isthermal=0;
    21 md.transient.isprognostic=0;
     21md.transient.ismasstransport=0;
    2222md.transient.isdiagnostic=1;
    2323md.transient.isgroundingline=1;

  • issm/trunk-jpl/test/NightlyRun/test423.py

    r15565 r15767  
    3030
    3131md.transient.isthermal=False
    32 md.transient.isprognostic=False
     32md.transient.ismasstransport=False
    3333md.transient.isdiagnostic=True
    3434md.transient.isgroundingline=True

  • issm/trunk-jpl/test/NightlyRun/test433.m

    r15565 r15767  
    2020
    2121md.transient.isthermal=0;
    22 md.transient.isprognostic=0;
     22md.transient.ismasstransport=0;
    2323md.transient.isdiagnostic=0;
    2424md.transient.isgroundingline=1;

  • issm/trunk-jpl/test/NightlyRun/test433.py

    r15565 r15767  
    3131
    3232md.transient.isthermal=False
    33 md.transient.isprognostic=False
     33md.transient.ismasstransport=False
    3434md.transient.isdiagnostic=False
    3535md.transient.isgroundingline=True

  • issm/trunk-jpl/test/NightlyRun/test515.m

    r15565 r15767  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.transient.isdiagnostic=0;
    9 md.transient.isprognostic=0;
     9md.transient.ismasstransport=0;
    1010md.transient.isthermal=1;
    1111md.transient.isgroundingline=0;

  • issm/trunk-jpl/test/NightlyRun/test515.py

    r15565 r15767  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.transient.isdiagnostic=False
    18 md.transient.isprognostic=False
     18md.transient.ismasstransport=False
    1919md.transient.isthermal=True
    2020md.transient.isgroundingline=False

  • issm/trunk-jpl/test/NightlyRun/test601.m

    r15565 r15767  
    44md=setflowequation(md,'SSA','all');
    55md.cluster=generic('name',oshostname(),'np',3);
    6 md=solve(md,PrognosticSolutionEnum());
     6md=solve(md,MasstransportSolutionEnum());
    77
    88%Fields and tolerances to track changes
    … …  
    1010field_tolerances={1e-13};
    1111field_values={...
    12         (md.results.PrognosticSolution.Thickness),...
     12        (md.results.MasstransportSolution.Thickness),...
    1313        };

  • issm/trunk-jpl/test/NightlyRun/test601.py

    r15565 r15767  
    1313md=setflowequation(md,'SSA','all')
    1414md.cluster=generic('name',oshostname(),'np',3)
    15 md=solve(md,PrognosticSolutionEnum())
     15md=solve(md,MasstransportSolutionEnum())
    1616
    1717#Fields and tolerances to track changes
    … …  
    1919field_tolerances=[1e-13]
    2020field_values=[\
    21         md.results.PrognosticSolution.Thickness,\
     21        md.results.MasstransportSolution.Thickness,\
    2222        ]

  • issm/trunk-jpl/test/NightlyRun/test602.m

    r15565 r15767  
    44md=parameterize(md,'../Par/79North.par');
    55md=setflowequation(md,'SSA','all');
    6 md.prognostic.stabilization=3;
    7 md.prognostic.spcthickness=md.geometry.thickness;
     6md.masstransport.stabilization=3;
     7md.masstransport.spcthickness=md.geometry.thickness;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,PrognosticSolutionEnum());
     9md=solve(md,MasstransportSolutionEnum());
    1010
    1111%Fields and tolerances to track changes
    … …  
    1313field_tolerances={1e-13};
    1414field_values={...
    15         (md.results.PrognosticSolution.Thickness),...
     15        (md.results.MasstransportSolution.Thickness),...
    1616        };

  • issm/trunk-jpl/test/NightlyRun/test602.py

    r15565 r15767  
    1515md=parameterize(md,'../Par/79North.py')
    1616md=setflowequation(md,'SSA','all')
    17 md.prognostic.stabilization=3
    18 md.prognostic.spcthickness=md.geometry.thickness
     17md.masstransport.stabilization=3
     18md.masstransport.spcthickness=md.geometry.thickness
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,PrognosticSolutionEnum())
     20md=solve(md,MasstransportSolutionEnum())
    2121
    2222#Fields and tolerances to track changes
    … …  
    2424field_tolerances=[1e-13]
    2525field_values=[\
    26         md.results.PrognosticSolution.Thickness,\
     26        md.results.MasstransportSolution.Thickness,\
    2727        ]

  • issm/trunk-jpl/test/NightlyRun/test603.m

    r15565 r15767  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,PrognosticSolutionEnum());
     7md=solve(md,MasstransportSolutionEnum());
    88
    99%Fields and tolerances to track changes
    … …  
    1111field_tolerances={1e-13};
    1212field_values={...
    13         (md.results.PrognosticSolution.Thickness),...
     13        (md.results.MasstransportSolution.Thickness),...
    1414        };

  • issm/trunk-jpl/test/NightlyRun/test603.py

    r15565 r15767  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,PrognosticSolutionEnum())
     17md=solve(md,MasstransportSolutionEnum())
    1818
    1919#Fields and tolerances to track changes
    … …  
    2121field_tolerances=[1e-13]
    2222field_values=[\
    23         md.results.PrognosticSolution.Thickness,\
     23        md.results.MasstransportSolution.Thickness,\
    2424        ]

  • issm/trunk-jpl/test/NightlyRun/test611.m

    r15565 r15767  
    66%control parameters
    77md.inversion.nsteps=2;
    8 md.prognostic.stabilization=1;
     8md.masstransport.stabilization=1;
    99md.inversion.iscontrol=1;
    1010md.inversion.control_parameters={'BalancethicknessThickeningRate'};

  • issm/trunk-jpl/test/NightlyRun/test611.py

    r15565 r15767  
    1616#control parameters
    1717md.inversion.nsteps=2
    18 md.prognostic.stabilization=1
     18md.masstransport.stabilization=1
    1919md.inversion.iscontrol=1
    2020md.inversion.control_parameters=['BalancethicknessThickeningRate']

  • issm/trunk-jpl/test/Par/79North.par

    r13675 r15767  
    3636%Numerical parameters
    3737md.diagnostic.viscosity_overshoot=0.3;
    38 md.prognostic.stabilization=1;
     38md.masstransport.stabilization=1;
    3939md.thermal.stabilization=1;
    4040md.verbose=verbose(0);
    … …  
    5151pos=find(md.mesh.vertexonboundary);
    5252md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos);
    53 md.prognostic.spcthickness(pos)=md.geometry.thickness(pos);
     53md.masstransport.spcthickness(pos)=md.geometry.thickness(pos);
    5454
    5555%Change name so that no test have the same name

  • issm/trunk-jpl/test/Par/79North.py

    r13676 r15767  
    4848#Numerical parameters
    4949md.diagnostic.viscosity_overshoot=0.3
    50 md.prognostic.stabilization=1
     50md.masstransport.stabilization=1
    5151md.thermal.stabilization=1
    5252md.verbose=verbose(0)
    … …  
    6363pos=numpy.nonzero(md.mesh.vertexonboundary)
    6464md.balancethickness.spcthickness[pos]=md.geometry.thickness[pos]
    65 md.prognostic.spcthickness[pos]=md.geometry.thickness[pos]
     65md.masstransport.spcthickness[pos]=md.geometry.thickness[pos]
    6666
    6767#Change name so that no test have the same name

  • issm/trunk-jpl/test/Par/GiaBenchmarksAB.par

    r14902 r15767  
    5353%Numerical parameters
    5454md.diagnostic.viscosity_overshoot=0.0;
    55 md.prognostic.stabilization=1.;
     55md.masstransport.stabilization=1.;
    5656md.thermal.stabilization=1.;
    5757md.verbose=verbose(0);

  • issm/trunk-jpl/test/Par/GiaBenchmarksCD.par

    r14902 r15767  
    5252%Numerical parameters
    5353md.diagnostic.viscosity_overshoot=0.0;
    54 md.prognostic.stabilization=1.;
     54md.masstransport.stabilization=1.;
    5555md.thermal.stabilization=1.;
    5656md.verbose=verbose(0);

  • issm/trunk-jpl/test/Par/ISMIPF.par

    r14432 r15767  
    3131md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    3232md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos);
    33 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    34 md.prognostic.spcthickness(pos)=md.geometry.thickness(pos);
     33md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     34md.masstransport.spcthickness(pos)=md.geometry.thickness(pos);
    3535md.thermal.spctemperature=255.*ones(md.mesh.numberofvertices,1);
    3636md.basalforcings.geothermalflux=0.4*ones(md.mesh.numberofvertices,1);
    … …  
    4242md.timestepping.time_step=1.;
    4343md.timestepping.final_time=10.;
    44 md.prognostic.stabilization=1;
     44md.masstransport.stabilization=1;
    4545md.thermal.stabilization=1;
    4646md.thermal.penalty_threshold=10^5;

  • issm/trunk-jpl/test/Par/ISMIPF.py

    r14432 r15767  
    3434md.balancethickness.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    3535md.balancethickness.spcthickness[pos]=md.geometry.thickness[pos]
    36 md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    37 md.prognostic.spcthickness[pos]=md.geometry.thickness[pos]
     36md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
     37md.masstransport.spcthickness[pos]=md.geometry.thickness[pos]
    3838md.thermal.spctemperature=255.*numpy.ones((md.mesh.numberofvertices,1))
    3939md.basalforcings.geothermalflux=0.4*numpy.ones((md.mesh.numberofvertices,1))
    … …  
    4545md.timestepping.time_step=1.
    4646md.timestepping.final_time=10.
    47 md.prognostic.stabilization=1
     47md.masstransport.stabilization=1
    4848md.thermal.stabilization=1
    4949md.thermal.penalty_threshold=10**5

  • issm/trunk-jpl/test/Par/Pig.par

    r15614 r15767  
    3535%Numerical parameters
    3636md.diagnostic.viscosity_overshoot=0.3;
    37 md.prognostic.stabilization=1;
     37md.masstransport.stabilization=1;
    3838md.verbose=verbose(0);
    3939md.settings.waitonlock=30;

  • issm/trunk-jpl/test/Par/Pig.py

    r15614 r15767  
    4646#Numerical parameters
    4747md.diagnostic.viscosity_overshoot=0.3
    48 md.prognostic.stabilization=1.
     48md.masstransport.stabilization=1.
    4949md.verbose=verbose(0)
    5050md.settings.waitonlock=30

  • issm/trunk-jpl/test/Par/RoundSheetShelf.par

    r15614 r15767  
    7676%Numerical parameters
    7777md.diagnostic.viscosity_overshoot=0.0;
    78 md.prognostic.stabilization=1;
     78md.masstransport.stabilization=1;
    7979md.thermal.stabilization=1;
    8080md.verbose=verbose(0);
    … …  
    103103md.mask.icelevelset(find(md.mesh.vertexonboundary))=0;
    104104md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    105 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     105md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    106106md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    107107md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);

  • issm/trunk-jpl/test/Par/RoundSheetShelf.py

    r15614 r15767  
    8484#Numerical parameters
    8585md.diagnostic.viscosity_overshoot=0.0
    86 md.prognostic.stabilization=1
     86md.masstransport.stabilization=1
    8787md.thermal.stabilization=1
    8888md.verbose=verbose(0)
    … …  
    113113md.mask.icelevelset[pos]=0
    114114md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    115 md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     115md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    116116md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
    117117md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))

  • issm/trunk-jpl/test/Par/SquareEISMINT.par

    r14106 r15767  
    3939md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    4040md.balancethickness.spcthickness(pos)=500.;
    41 md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    42 md.prognostic.spcthickness(pos)=500.;
    43 md.prognostic.stabilization=0; %Better result with no artificial diffusivity
     41md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     42md.masstransport.spcthickness(pos)=500.;
     43md.masstransport.stabilization=0; %Better result with no artificial diffusivity
    4444md.thermal.stabilization=0;
    4545md.timestepping.final_time=500.;

  • issm/trunk-jpl/test/Par/SquareEISMINT.py

    r14106 r15767  
    4242md.balancethickness.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    4343md.balancethickness.spcthickness[pos]=500.
    44 md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    45 md.prognostic.spcthickness[pos]=500.
    46 md.prognostic.stabilization=0    #Better result with no artificial diffusivity
     44md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
     45md.masstransport.spcthickness[pos]=500.
     46md.masstransport.stabilization=0    #Better result with no artificial diffusivity
    4747md.thermal.stabilization=0
    4848md.timestepping.final_time=500.

  • issm/trunk-jpl/test/Par/SquareSheetConstrained.par

    r14902 r15767  
    3838%Numerical parameters
    3939md.diagnostic.viscosity_overshoot=0.0;
    40 md.prognostic.stabilization=1.;
     40md.masstransport.stabilization=1.;
    4141md.thermal.stabilization=1.;
    4242md.verbose=verbose(0);

  • issm/trunk-jpl/test/Par/SquareSheetConstrained.py

    r14902 r15767  
    4848#Numerical parameters
    4949md.diagnostic.viscosity_overshoot=0.0
    50 md.prognostic.stabilization=1.
     50md.masstransport.stabilization=1.
    5151md.thermal.stabilization=1.
    5252md.verbose=verbose(0)

  • issm/trunk-jpl/test/Par/SquareSheetShelf.par

    r13676 r15767  
    4343%Numerical parameters
    4444md.diagnostic.viscosity_overshoot=0.0;
    45 md.prognostic.stabilization=1;
     45md.masstransport.stabilization=1;
    4646md.thermal.stabilization=1;
    4747md.verbose=verbose(0);

  • issm/trunk-jpl/test/Par/SquareSheetShelf.py

    r14102 r15767  
    5454#Numerical parameters
    5555md.diagnostic.viscosity_overshoot=0.0
    56 md.prognostic.stabilization=1
     56md.masstransport.stabilization=1
    5757md.thermal.stabilization=1
    5858md.verbose=verbose(0)

  • issm/trunk-jpl/test/Par/SquareShelf.par

    r13234 r15767  
    3636%Numerical parameters
    3737md.diagnostic.viscosity_overshoot=0.3;
    38 md.prognostic.stabilization=1;
     38md.masstransport.stabilization=1;
    3939md.thermal.stabilization=1;
    4040md.settings.waitonlock=30;

  • issm/trunk-jpl/test/Par/SquareShelf.py

    r14318 r15767  
    6767#Numerical parameters
    6868md.diagnostic.viscosity_overshoot = 0.3
    69 md.prognostic.stabilization = 1.
     69md.masstransport.stabilization = 1.
    7070md.thermal.stabilization = 1.
    7171md.settings.waitonlock = 30

  • issm/trunk-jpl/test/Par/SquareShelf2.par

    r15547 r15767  
    3636%Numerical parameters
    3737md.diagnostic.viscosity_overshoot=0.3;
    38 md.prognostic.stabilization=1;
     38md.masstransport.stabilization=1;
    3939md.thermal.stabilization=1;
    4040md.settings.waitonlock=30;

  • issm/trunk-jpl/test/Par/SquareShelf2.py

    r15587 r15767  
    6767#Numerical parameters
    6868md.diagnostic.viscosity_overshoot = 0.3
    69 md.prognostic.stabilization = 1.
     69md.masstransport.stabilization = 1.
    7070md.thermal.stabilization = 1.
    7171md.settings.waitonlock = 30

  • issm/trunk-jpl/test/Par/SquareShelfConstrained.par

    r13234 r15767  
    4040%Numerical parameters
    4141md.diagnostic.viscosity_overshoot=0.0;
    42 md.prognostic.stabilization=1;
     42md.masstransport.stabilization=1;
    4343md.thermal.stabilization=1;
    4444md.verbose=verbose(0);

  • issm/trunk-jpl/test/Par/SquareShelfConstrained.py

    r14102 r15767  
    5252#Numerical parameters
    5353md.diagnostic.viscosity_overshoot=0.0
    54 md.prognostic.stabilization=1.
     54md.masstransport.stabilization=1.
    5555md.thermal.stabilization=1.
    5656md.verbose = verbose(0)
Note: See TracChangeset for help on using the changeset viewer.