Changeset 25627


Ignore:
Timestamp:
10/05/20 16:30:06 (4 years ago)
Author:
jdquinn
Message:

CHG: Merging changes from Eric’s branch (still need to get Eric to look at rigid); blocking warning about deprecated ‘register’ in Dakota

Location:
issm/trunk-jpl
Files:
1 added
1 deleted
40 edited
13 copied

Legend:

Unmodified
Added
Removed

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

    r25570 r25627  
    24752475        dnl optimization{{{
    24762476        dnl -- bypass standard optimization -g -O2 -fPIC -std=c++11?
     2477        dnl NOTE: Added -Wno-deprecated-register flag to clear,
     2478        dnl
     2479        dnl             externalpackages/dakota/install/include/MPIPackBuffer.hpp:301:8: warning:
     2480        dnl             'register' storage class specifier is deprecated and incompatible with
     2481        dnl             C++17 [-Wdeprecated-register]
     2482        dnl             for (register typename ContainerT::size_type i=0; i<len; ++i) {
     2483        dnl
     2484        dnl when Dakota 6.2 is installed (may be an issue in other versions; likely
     2485        dnl will not be needed at all in future versions)
     2486        dnl
    24772487        AC_ARG_WITH(
    24782488                [cxxoptflags],
    2479                 AS_HELP_STRING([--with-cxxoptflags=CXXOPTFLAGS], [C++ optimization flags (i.e. --with-cxxoptflags="-march=opteron -O3 -std=c++11 "]),
     2489                AS_HELP_STRING([--with-cxxoptflags=CXXOPTFLAGS], [C++ optimization flags (i.e. --with-cxxoptflags="-march=opteron -O3 -std=c++11 -Wno-deprecated-register"]),
    24802490                [CXXOPTFLAGS=${withval}],
    2481                 [CXXOPTFLAGS="-g -O2 -fPIC -std=c++11"]
     2491                [CXXOPTFLAGS="-g -O2 -fPIC -std=c++11 -Wno-deprecated-register"]
    24822492        )
    24832493        AC_MSG_CHECKING(for C++ optimization flags)

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

    r25530 r25627  
    352352        ./modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp \
    353353        ./modules/ModelProcessorx/Dakota/UpdateElementsAndMaterialsDakota.cpp \
     354        ./modules/QmuStatisticsx/QmuStatisticsx.cpp  \
    354355        ./cores/dakota_core.cpp
    355356endif
    … …  
    637638        ./modules/NodeConnectivityx/NodeConnectivityx.cpp \
    638639        ./modules/ElementConnectivityx/ElementConnectivityx.cpp \
    639         ./modules/PropagateFlagsFromConnectivityx/PropagateFlagsFromConnectivityx.cpp
     640        ./modules/PropagateFlagsFromConnectivityx/PropagateFlagsFromConnectivityx.cpp 
    640641
    641642if CHACO
    … …  
    762763bin_PROGRAMS =
    763764else
    764 bin_PROGRAMS = issm issm_slr
     765bin_PROGRAMS = issm issm_slr issm_post
    765766endif
    766767endif
    … …  
    779780endif
    780781
    781 issm_SOURCES = main/issm.cpp
     782issm_SOURCES = main/issm.cpp 
    782783issm_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
    783784
    784785issm_slr_SOURCES = main/issm_slr.cpp
    785786issm_slr_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
     787
     788issm_post_SOURCES = main/issm_post.cpp
     789issm_post_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
    786790
    787791if OCEAN

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

    r25539 r25627  
    175175        IssmDouble  planetradius=0;
    176176        IssmDouble  planetarea=0;
     177        bool         elastic=false;
    177178
    178179        int     numoutputs;
    … …  
    201202        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.computesealevelchange",SolidearthSettingsComputesealevelchangeEnum));
    202203        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.planetradius",SolidearthPlanetRadiusEnum));
     204        parameters->AddObject(new DoubleParam(CumBslrEnum,0.0));
     205        parameters->AddObject(new DoubleParam(CumBslrIceEnum,0.0));
     206        parameters->AddObject(new DoubleParam(CumBslrHydroEnum,0.0));
     207        parameters->AddObject(new DoubleParam(CumGmtslrEnum,0.0));
    203208
    204209        /*compute planet area and plug into parameters:*/
    … …  
    226231        } /*}}}*/
    227232        /*Deal with elasticity {{{*/
    228         /*love numbers: */
    229         iomodel->FetchData(&love_h,&nl,NULL,"md.solidearth.lovenumbers.h");
    230         iomodel->FetchData(&love_k,&nl,NULL,"md.solidearth.lovenumbers.k");
    231         iomodel->FetchData(&love_l,&nl,NULL,"md.solidearth.lovenumbers.l");
    232         iomodel->FetchData(&love_th,&nl,NULL,"md.solidearth.lovenumbers.th");
    233         iomodel->FetchData(&love_tk,&nl,NULL,"md.solidearth.lovenumbers.tk");
    234         iomodel->FetchData(&love_tl,&nl,NULL,"md.solidearth.lovenumbers.tl");
    235         parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.lovenumbers.tk2secular",TidalLoveK2SecularEnum));
    236 
    237         parameters->AddObject(new DoubleMatParam(LoadLoveHEnum,love_h,nl,1));
    238         parameters->AddObject(new DoubleMatParam(LoadLoveKEnum,love_k,nl,1));
    239         parameters->AddObject(new DoubleMatParam(LoadLoveLEnum,love_l,nl,1));
    240         parameters->AddObject(new DoubleMatParam(TidalLoveHEnum,love_th,nl,1));
    241         parameters->AddObject(new DoubleMatParam(TidalLoveKEnum,love_tk,nl,1));
    242         parameters->AddObject(new DoubleMatParam(TidalLoveLEnum,love_tl,nl,1));
    243 
    244         /*compute elastic green function for a range of angles*/
    245         iomodel->FetchData(&degacc,"md.solidearth.settings.degacc");
    246         M=reCast<int,IssmDouble>(180./degacc+1.);
    247 
    248         // AD performance is sensitive to calls to ensurecontiguous.
    249         // // Providing "t" will cause ensurecontiguous to be called.
    250         #ifdef _HAVE_AD_
    251         G_rigid=xNew<IssmDouble>(M,"t");
    252         G_elastic=xNew<IssmDouble>(M,"t");
    253         U_elastic=xNew<IssmDouble>(M,"t");
    254         H_elastic=xNew<IssmDouble>(M,"t");
    255         #else
    256         G_rigid=xNew<IssmDouble>(M);
    257         G_elastic=xNew<IssmDouble>(M);
    258         U_elastic=xNew<IssmDouble>(M);
    259         H_elastic=xNew<IssmDouble>(M);
    260         #endif
    261 
    262         /*compute combined legendre + love number (elastic green function:*/
    263         m=DetermineLocalSize(M,IssmComm::GetComm());
    264         GetOwnershipBoundariesFromRange(&lower_row,&upper_row,m,IssmComm::GetComm());
    265         // AD performance is sensitive to calls to ensurecontiguous.
    266         // // Providing "t" will cause ensurecontiguous to be called.
    267         #ifdef _HAVE_AD_
    268         G_elastic_local=xNew<IssmDouble>(m,"t");
    269         G_rigid_local=xNew<IssmDouble>(m,"t");
    270         U_elastic_local=xNew<IssmDouble>(m,"t");
    271         H_elastic_local=xNew<IssmDouble>(m,"t");
    272         #else
    273         G_elastic_local=xNew<IssmDouble>(m);
    274         G_rigid_local=xNew<IssmDouble>(m);
    275         U_elastic_local=xNew<IssmDouble>(m);
    276         H_elastic_local=xNew<IssmDouble>(m);
    277         #endif
    278 
    279         for(int i=lower_row;i<upper_row;i++){
    280                 IssmDouble alpha,x;
    281                 alpha= reCast<IssmDouble>(i)*degacc * PI / 180.0;
    282 
    283                 G_rigid_local[i-lower_row]= .5/sin(alpha/2.0);
    284                 G_elastic_local[i-lower_row]= (love_k[nl-1]-love_h[nl-1])*G_rigid_local[i-lower_row];
    285                 U_elastic_local[i-lower_row]= (love_h[nl-1])*G_rigid_local[i-lower_row];
    286                 H_elastic_local[i-lower_row]= 0;
    287                 IssmDouble Pn = 0.;
    288                 IssmDouble Pn1 = 0.;
    289                 IssmDouble Pn2 = 0.;
    290                 IssmDouble Pn_p = 0.;
    291                 IssmDouble Pn_p1 = 0.;
    292                 IssmDouble Pn_p2 = 0.;
    293 
    294                 for (int n=0;n<nl;n++) {
    295                         IssmDouble deltalove_G;
    296                         IssmDouble deltalove_U;
    297 
    298                         deltalove_G = (love_k[n]-love_k[nl-1]-love_h[n]+love_h[nl-1]);
    299                         deltalove_U = (love_h[n]-love_h[nl-1]);
    300 
    301                         /*compute legendre polynomials: P_n(cos\theta) & d P_n(cos\theta)/ d\theta: */
    302                         if(n==0){
    303                                 Pn=1;
    304                                 Pn_p=0;
     233        iomodel->FetchData(&elastic,"md.solidearth.settings.elastic");
     234// if(elastic){
     235                /*love numbers: */
     236                iomodel->FetchData(&love_h,&nl,NULL,"md.solidearth.lovenumbers.h");
     237                iomodel->FetchData(&love_k,&nl,NULL,"md.solidearth.lovenumbers.k");
     238                iomodel->FetchData(&love_l,&nl,NULL,"md.solidearth.lovenumbers.l");
     239                iomodel->FetchData(&love_th,&nl,NULL,"md.solidearth.lovenumbers.th");
     240                iomodel->FetchData(&love_tk,&nl,NULL,"md.solidearth.lovenumbers.tk");
     241                iomodel->FetchData(&love_tl,&nl,NULL,"md.solidearth.lovenumbers.tl");
     242                parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.lovenumbers.tk2secular",TidalLoveK2SecularEnum));
     243
     244                parameters->AddObject(new DoubleMatParam(LoadLoveHEnum,love_h,nl,1));
     245                parameters->AddObject(new DoubleMatParam(LoadLoveKEnum,love_k,nl,1));
     246                parameters->AddObject(new DoubleMatParam(LoadLoveLEnum,love_l,nl,1));
     247                parameters->AddObject(new DoubleMatParam(TidalLoveHEnum,love_th,nl,1));
     248                parameters->AddObject(new DoubleMatParam(TidalLoveKEnum,love_tk,nl,1));
     249                parameters->AddObject(new DoubleMatParam(TidalLoveLEnum,love_tl,nl,1));
     250
     251                /*compute elastic green function for a range of angles*/
     252                iomodel->FetchData(&degacc,"md.solidearth.settings.degacc");
     253                M=reCast<int,IssmDouble>(180./degacc+1.);
     254
     255                // AD performance is sensitive to calls to ensurecontiguous.
     256                // // Providing "t" will cause ensurecontiguous to be called.
     257                #ifdef _HAVE_AD_
     258                G_rigid=xNew<IssmDouble>(M,"t");
     259                G_elastic=xNew<IssmDouble>(M,"t");
     260                U_elastic=xNew<IssmDouble>(M,"t");
     261                H_elastic=xNew<IssmDouble>(M,"t");
     262                #else
     263                G_rigid=xNew<IssmDouble>(M);
     264                G_elastic=xNew<IssmDouble>(M);
     265                U_elastic=xNew<IssmDouble>(M);
     266                H_elastic=xNew<IssmDouble>(M);
     267                #endif
     268
     269                /*compute combined legendre + love number (elastic green function:*/
     270                m=DetermineLocalSize(M,IssmComm::GetComm());
     271                GetOwnershipBoundariesFromRange(&lower_row,&upper_row,m,IssmComm::GetComm());
     272                // AD performance is sensitive to calls to ensurecontiguous.
     273                // // Providing "t" will cause ensurecontiguous to be called.
     274                #ifdef _HAVE_AD_
     275                G_elastic_local=xNew<IssmDouble>(m,"t");
     276                G_rigid_local=xNew<IssmDouble>(m,"t");
     277                U_elastic_local=xNew<IssmDouble>(m,"t");
     278                H_elastic_local=xNew<IssmDouble>(m,"t");
     279                #else
     280                G_elastic_local=xNew<IssmDouble>(m);
     281                G_rigid_local=xNew<IssmDouble>(m);
     282                U_elastic_local=xNew<IssmDouble>(m);
     283                H_elastic_local=xNew<IssmDouble>(m);
     284                #endif
     285
     286                for(int i=lower_row;i<upper_row;i++){
     287                        IssmDouble alpha,x;
     288                        alpha= reCast<IssmDouble>(i)*degacc * PI / 180.0;
     289
     290                        G_rigid_local[i-lower_row]= .5/sin(alpha/2.0);
     291                        G_elastic_local[i-lower_row]= (love_k[nl-1]-love_h[nl-1])*G_rigid_local[i-lower_row];
     292                        U_elastic_local[i-lower_row]= (love_h[nl-1])*G_rigid_local[i-lower_row];
     293                        H_elastic_local[i-lower_row]= 0;
     294                        IssmDouble Pn = 0.;
     295                        IssmDouble Pn1 = 0.;
     296                        IssmDouble Pn2 = 0.;
     297                        IssmDouble Pn_p = 0.;
     298                        IssmDouble Pn_p1 = 0.;
     299                        IssmDouble Pn_p2 = 0.;
     300
     301                        for (int n=0;n<nl;n++) {
     302                                IssmDouble deltalove_G;
     303                                IssmDouble deltalove_U;
     304
     305                                deltalove_G = (love_k[n]-love_k[nl-1]-love_h[n]+love_h[nl-1]);
     306                                deltalove_U = (love_h[n]-love_h[nl-1]);
     307
     308                                /*compute legendre polynomials: P_n(cos\theta) & d P_n(cos\theta)/ d\theta: */
     309                                if(n==0){
     310                                        Pn=1;
     311                                        Pn_p=0;
     312                                }
     313                                else if(n==1){
     314                                        Pn = cos(alpha);
     315                                        Pn_p = 1;
     316                                }
     317                                else{
     318                                        Pn = ( (2*n-1)*cos(alpha)*Pn1 - (n-1)*Pn2 ) /n;
     319                                        Pn_p = ( (2*n-1)*(Pn1+cos(alpha)*Pn_p1) - (n-1)*Pn_p2 ) /n;
     320                                }
     321                                Pn2=Pn1; Pn1=Pn;
     322                                Pn_p2=Pn_p1; Pn_p1=Pn_p;
     323
     324                                G_elastic_local[i-lower_row] += deltalove_G*Pn;         // gravitational potential
     325                                U_elastic_local[i-lower_row] += deltalove_U*Pn;         // vertical (up) displacement
     326                                H_elastic_local[i-lower_row] += sin(alpha)*love_l[n]*Pn_p;              // horizontal displacements
    305327                        }
    306                         else if(n==1){
    307                                 Pn = cos(alpha);
    308                                 Pn_p = 1;
    309                         }
    310                         else{
    311                                 Pn = ( (2*n-1)*cos(alpha)*Pn1 - (n-1)*Pn2 ) /n;
    312                                 Pn_p = ( (2*n-1)*(Pn1+cos(alpha)*Pn_p1) - (n-1)*Pn_p2 ) /n;
    313                         }
    314                         Pn2=Pn1; Pn1=Pn;
    315                         Pn_p2=Pn_p1; Pn_p1=Pn_p;
    316 
    317                         G_elastic_local[i-lower_row] += deltalove_G*Pn;         // gravitational potential
    318                         U_elastic_local[i-lower_row] += deltalove_U*Pn;         // vertical (up) displacement
    319                         H_elastic_local[i-lower_row] += sin(alpha)*love_l[n]*Pn_p;              // horizontal displacements
    320                 }
    321         }
    322 
    323         /*merge G_elastic_local into G_elastic; U_elastic_local into U_elastic; H_elastic_local to H_elastic:{{{*/
    324         int* recvcounts=xNew<int>(IssmComm::GetSize());
    325         int* displs=xNew<int>(IssmComm::GetSize());
    326 
    327         //recvcounts:
    328         ISSM_MPI_Allgather(&m,1,ISSM_MPI_INT,recvcounts,1,ISSM_MPI_INT,IssmComm::GetComm());
    329 
    330         /*displs: */
    331         ISSM_MPI_Allgather(&lower_row,1,ISSM_MPI_INT,displs,1,ISSM_MPI_INT,IssmComm::GetComm());
    332 
    333         /*All gather:*/
    334         ISSM_MPI_Allgatherv(G_rigid_local, m, ISSM_MPI_DOUBLE, G_rigid, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
    335         ISSM_MPI_Allgatherv(G_elastic_local, m, ISSM_MPI_DOUBLE, G_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
    336         ISSM_MPI_Allgatherv(U_elastic_local, m, ISSM_MPI_DOUBLE, U_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
    337         ISSM_MPI_Allgatherv(H_elastic_local, m, ISSM_MPI_DOUBLE, H_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
    338         /*free ressources: */
    339         xDelete<int>(recvcounts);
    340         xDelete<int>(displs);
    341 
    342         /*}}}*/
    343 
    344         /*Avoid singularity at 0: */
    345         G_rigid[0]=G_rigid[1];
    346         parameters->AddObject(new DoubleVecParam(SealevelriseGRigidEnum,G_rigid,M));
    347         G_elastic[0]=G_elastic[1];
    348         parameters->AddObject(new DoubleVecParam(SealevelriseGElasticEnum,G_elastic,M));
    349         U_elastic[0]=U_elastic[1];
    350         parameters->AddObject(new DoubleVecParam(SealevelriseUElasticEnum,U_elastic,M));
    351         H_elastic[0]=H_elastic[1];
    352         parameters->AddObject(new DoubleVecParam(SealevelriseHElasticEnum,H_elastic,M));
    353 
    354         /*free ressources: */
    355         xDelete<IssmDouble>(love_h);
    356         xDelete<IssmDouble>(love_k);
    357         xDelete<IssmDouble>(love_l);
    358         xDelete<IssmDouble>(love_th);
    359         xDelete<IssmDouble>(love_tk);
    360         xDelete<IssmDouble>(love_tl);
    361         xDelete<IssmDouble>(G_rigid);
    362         xDelete<IssmDouble>(G_rigid_local);
    363         xDelete<IssmDouble>(G_elastic);
    364         xDelete<IssmDouble>(G_elastic_local);
    365         xDelete<IssmDouble>(U_elastic);
    366         xDelete<IssmDouble>(U_elastic_local);
    367         xDelete<IssmDouble>(H_elastic);
    368         xDelete<IssmDouble>(H_elastic_local);
     328                }
     329
     330                /*merge G_elastic_local into G_elastic; U_elastic_local into U_elastic; H_elastic_local to H_elastic:{{{*/
     331                int* recvcounts=xNew<int>(IssmComm::GetSize());
     332                int* displs=xNew<int>(IssmComm::GetSize());
     333
     334                //recvcounts:
     335                ISSM_MPI_Allgather(&m,1,ISSM_MPI_INT,recvcounts,1,ISSM_MPI_INT,IssmComm::GetComm());
     336
     337                /*displs: */
     338                ISSM_MPI_Allgather(&lower_row,1,ISSM_MPI_INT,displs,1,ISSM_MPI_INT,IssmComm::GetComm());
     339
     340                /*All gather:*/
     341                ISSM_MPI_Allgatherv(G_rigid_local, m, ISSM_MPI_DOUBLE, G_rigid, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
     342                ISSM_MPI_Allgatherv(G_elastic_local, m, ISSM_MPI_DOUBLE, G_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
     343                ISSM_MPI_Allgatherv(U_elastic_local, m, ISSM_MPI_DOUBLE, U_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
     344                ISSM_MPI_Allgatherv(H_elastic_local, m, ISSM_MPI_DOUBLE, H_elastic, recvcounts, displs, ISSM_MPI_DOUBLE,IssmComm::GetComm());
     345               
     346                /*free resources: */
     347                xDelete<int>(recvcounts);
     348                xDelete<int>(displs);
     349
     350                /*}}}*/
     351
     352                /*Avoid singularity at 0: */
     353                G_rigid[0]=G_rigid[1];
     354                parameters->AddObject(new DoubleVecParam(SealevelriseGRigidEnum,G_rigid,M));
     355                G_elastic[0]=G_elastic[1];
     356                parameters->AddObject(new DoubleVecParam(SealevelriseGElasticEnum,G_elastic,M));
     357                U_elastic[0]=U_elastic[1];
     358                parameters->AddObject(new DoubleVecParam(SealevelriseUElasticEnum,U_elastic,M));
     359                H_elastic[0]=H_elastic[1];
     360                parameters->AddObject(new DoubleVecParam(SealevelriseHElasticEnum,H_elastic,M));
     361
     362                /*free resources: */
     363                xDelete<IssmDouble>(love_h);
     364                xDelete<IssmDouble>(love_k);
     365                xDelete<IssmDouble>(love_l);
     366                xDelete<IssmDouble>(love_th);
     367                xDelete<IssmDouble>(love_tk);
     368                xDelete<IssmDouble>(love_tl);
     369                xDelete<IssmDouble>(G_rigid);
     370                xDelete<IssmDouble>(G_rigid_local);
     371                xDelete<IssmDouble>(G_elastic);
     372                xDelete<IssmDouble>(G_elastic_local);
     373                xDelete<IssmDouble>(U_elastic);
     374                xDelete<IssmDouble>(U_elastic_local);
     375                xDelete<IssmDouble>(H_elastic);
     376                xDelete<IssmDouble>(H_elastic_local);
     377        // }
    369378       
    370379        /*Indicate we have not yet ran the Geometry Core module: */

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

    r25514 r25627  
    377377                virtual IssmDouble    OceanAverage(IssmDouble* Sg, SealevelMasks* masks)=0;
    378378                virtual void          SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks)=0;
    379                 virtual void          SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks,IssmDouble oceanarea)=0;
     379                virtual IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks,IssmDouble oceanarea)=0;
     380                virtual IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks,IssmDouble oceanarea)=0;
     381                virtual void          SealevelriseEustaticBottomPressure(IssmDouble* Sgi, SealevelMasks* masks)=0;
    380382                virtual void          SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz)=0;
    381383                virtual void          SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old,SealevelMasks* mask)=0;

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

    r25514 r25627  
    217217                void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    218218                void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    219                 void    SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks,IssmDouble oceanarea){_error_("not implemented yet!");};
     219                IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     220                IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     221                void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    220222                void    SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    221223                void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};

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

    r25508 r25627  
    173173                void    SetSealevelMasks(SealevelMasks* masks){_error_("not implemented yet!");};
    174174                void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    175                 void    SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks,IssmDouble oceanarea){_error_("not implemented yet!");};
     175                IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     176                IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     177                void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    176178                void    SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    177179                void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};

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

    r25508 r25627  
    179179                void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    180180                void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    181                 void    SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks,IssmDouble oceanarea){_error_("not implemented yet!");};
     181                IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     182                IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){_error_("not implemented yet!");};
     183                void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    182184                void    SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    183185                void    SealevelriseGeodetic(IssmDouble* Up ,IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};

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

    r25598 r25627  
    54685468        this->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
    54695469
     5470        /*compute area and add to inputs:*/
     5471        area=GetAreaSpherical();
     5472        this->inputs->SetDoubleInput(AreaEnum,this->lid,area);
     5473        this->AddInput(SealevelAreaEnum,&area,P0Enum);
     5474        if(!computerigid & !computeelastic)return;
     5475
    54705476        /*recover precomputed green function kernels:*/
    54715477        DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
    … …  
    54755481        parameter->GetParameterValueByPointer((IssmDouble**)&G_elastic_precomputed,&M);
    54765482
     5483        parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseUElasticEnum)); _assert_(parameter);
     5484        parameter->GetParameterValueByPointer((IssmDouble**)&U_elastic_precomputed,&M);
     5485
    54775486        parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseHElasticEnum)); _assert_(parameter);
    54785487        parameter->GetParameterValueByPointer((IssmDouble**)&H_elastic_precomputed,&M);
    5479 
    5480         parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseUElasticEnum)); _assert_(parameter);
    5481         parameter->GetParameterValueByPointer((IssmDouble**)&U_elastic_precomputed,&M);
    54825488
    54835489        /*allocate indices:*/
    … …  
    54905496        }
    54915497
    5492         /*compute area:*/
    5493         area=GetAreaSpherical();
    5494 
    5495 
     5498       
    54965499        /* Where is the centroid of this element:*/
    54975500
    … …  
    55585561                this->inputs->SetArrayInput(SealevelriseGEEnum,this->lid,GE,gsize);
    55595562        }
     5563
     5564        /* NOTE: May need to remove these two lines (from merge) */
    55605565        this->inputs->SetDoubleInput(AreaEnum,this->lid,area);
    55615566        this->AddInput(SealevelAreaEnum,&area,P0Enum);
    … …  
    55835588}
    55845589/*}}}*/
    5585 void    Tria::SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
    5586 
    5587         int bp_compute_fingerprints= 0;
    5588 
    5589         /*Compute bottom pressure contribution from ocean if requested:*/
    5590         this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
    5591         if(bp_compute_fingerprints)this->SealevelriseBottomPressure(Sgi,masks);
    5592 
    5593         /*Compute eustatic ice contribution to sea level rise: */
    5594         this->SealevelriseEustaticIce(Sgi,peustatic,masks, oceanarea);
    5595 
    5596         /*Compute hydrological contribution to sea level rise: */
    5597         this->SealevelriseEustaticHydro(Sgi,peustatic,masks, oceanarea);
    5598 
    5599 
    5600 }
    5601 /*}}}*/
    5602 void    Tria::SealevelriseEustaticIce(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
     5590IssmDouble Tria::SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
    56035591
    56045592        /*diverse:*/
    … …  
    56095597        bool notfullygrounded=false;
    56105598        bool scaleoceanarea= false;
     5599        bool computeelastic= true;
     5600
     5601        /*output: */
     5602        IssmDouble bslrice=0;
    56115603
    56125604        /*elastic green function:*/
    … …  
    56185610        /*constants:*/
    56195611        IssmDouble constant=0;
    5620 
    5621         /*Initialize eustatic component: do not skip this step :):*/
    5622         IssmDouble eustatic = 0.;
    56235612
    56245613        /*early return if we are not on an ice cap:*/
    … …  
    56275616                constant=0; this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
    56285617                #endif
    5629                 *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
    5630                 return;
     5618                bslrice=0;
     5619                return bslrice;
    56315620        }
    56325621
    … …  
    56375626                this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
    56385627                #endif
    5639                 *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
    5640                 return;
     5628                bslrice=0;
     5629                return bslrice;
    56415630        }
    56425631
    … …  
    56505639        #endif
    56515640
    5652         /*recover material parameters: */
     5641        /*recover some parameters:*/
    56535642        rho_ice=FindParam(MaterialsRhoIceEnum);
    56545643        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    5655 
    5656         /*recover ocean area scaling: */
     5644        this->parameters->FindParam(&computeelastic,SolidearthSettingsElasticEnum);
    56575645        this->parameters->FindParam(&scaleoceanarea,SolidearthSettingsOceanAreaScalingEnum);
    56585646
    56595647        /*retrieve precomputed G:*/
    5660         this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
     5648
     5649        /* NOTE: May need to remove condition here (from merge) */
     5650        if(computeelastic)this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    56615651
    56625652        /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
    … …  
    57025692        /*}}}*/
    57035693
    5704         /*Compute eustatic component:*/
     5694        /*Compute barystatic contribution:*/
    57055695        _assert_(oceanarea>0.);
    57065696        if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
    5707         eustatic += rho_ice*area*phi*I/(oceanarea*rho_water);
    5708 
    5709         /*convert from m to kg/m^2:*/
    5710         I=I*rho_ice*phi;
    5711 
    5712         /*convolve:*/
    5713         for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*I;
    5714 
    5715         /*Assign output pointer:*/
    5716         _assert_(!xIsNan<IssmDouble>(eustatic));
    5717         *peustatic=eustatic;
    5718         return;
    5719 }
    5720 /*}}}*/
    5721 void    Tria::SealevelriseEustaticHydro(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
     5697        bslrice = rho_ice*area*phi*I/(oceanarea*rho_water);
     5698        _assert_(!xIsNan<IssmDouble>(bslrice));
     5699
     5700        if(computeelastic){
     5701                /*convert from m to kg/m^2:*/
     5702                I=I*rho_ice*phi;
     5703
     5704                /*convolve:*/
     5705                for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*I;
     5706        }
     5707
     5708        /*return :*/
     5709        return bslrice;
     5710}
     5711/*}}}*/
     5712IssmDouble Tria::SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
    57225713
    57235714        /*diverse:*/
    57245715        int gsize;
    57255716        IssmDouble area;
    5726         IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes eustatic
     5717        IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes barystatic
    57275718        IssmDouble W;  //change in water height thickness (Farrel and Clarke, Equ. 4)
    57285719        bool notfullygrounded=false;
    57295720        bool scaleoceanarea= false;
     5721        bool computeelastic= true;
    57305722
    57315723        /*elastic green function:*/
    … …  
    57365728        IssmDouble rho_freshwater;
    57375729
    5738 
    5739         /*Initialize eustatic component: grab from the previous eustatic core!:*/
    5740         IssmDouble eustatic = *peustatic;
     5730        /*output:*/
     5731        IssmDouble bslrhydro = 0;
    57415732
    57425733        /*early return if we are on an ice cap:*/
    5743         if(masks->isiceonly[this->lid]){ return; }
     5734        if(masks->isiceonly[this->lid]){
     5735                bslrhydro=0;
     5736                return bslrhydro;
     5737        }
    57445738
    57455739        /*early return if we are fully floating:*/
    5746         if (masks->isfullyfloating[this->lid]){ return; }
     5740        if (masks->isfullyfloating[this->lid]){
     5741                bslrhydro=0;
     5742                return bslrhydro;
     5743        }
    57475744
    57485745        /*If we are here, we are on earth, not on ice: */
    57495746
    5750         /*recover material parameters: */
     5747        /*recover parameters: */
    57515748        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    57525749        rho_freshwater=FindParam(MaterialsRhoFreshwaterEnum);
    5753 
    5754         /*recover ocean area scaling: */
     5750        this->parameters->FindParam(&computeelastic,SolidearthSettingsElasticEnum);
    57555751        this->parameters->FindParam(&scaleoceanarea,SolidearthSettingsOceanAreaScalingEnum);
    57565752
    57575753        /*retrieve precomputed G:*/
    5758         this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
     5754
     5755        /* NOTE: May need to remove condition here (from merge) */
     5756        if(computeelastic)this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    57595757
    57605758        /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
    … …  
    57665764        deltathickness_input->GetInputAverage(&W);
    57675765
    5768         /*Compute eustatic component:*/
     5766        /*Compute barystatic component:*/
    57695767        _assert_(oceanarea>0.);
    57705768        if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
    5771         eustatic += rho_freshwater*area*phi*W/(oceanarea*rho_water);
    5772 
    5773         /*convert from m to kg/m^2:*/
    5774         W=W*rho_freshwater*phi;
    5775 
    5776         /*convolve:*/
    5777         for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*W;
    5778 
    5779         /*Assign output pointer:*/
    5780         _assert_(!xIsNan<IssmDouble>(eustatic));
    5781         *peustatic=eustatic; //do not forget the +, otherwise, you'll wipe out previous eustatic contributions!
    5782         return;
    5783 }
    5784 /*}}}*/
    5785 void    Tria::SealevelriseBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){ /*{{{*/
     5769        bslrhydro = rho_freshwater*area*phi*W/(oceanarea*rho_water);
     5770        _assert_(!xIsNan<IssmDouble>(bslrhydro));
     5771
     5772        if(computeelastic){
     5773                /*convert from m to kg/m^2:*/
     5774                W=W*rho_freshwater*phi;
     5775
     5776                /*convolve:*/
     5777                for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*W;
     5778        }
     5779
     5780        /*output:*/
     5781        return bslrhydro;
     5782}
     5783/*}}}*/
     5784void    Tria::SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){ /*{{{*/
    57865785
    57875786        /*diverse:*/
    … …  
    57905789        IssmDouble BP;  //change in bottom pressure (Farrel and Clarke, Equ. 4)
    57915790        IssmDouble constant;
     5791        bool computeelastic= true;
    57925792
    57935793        /*elastic green function:*/
    … …  
    57965796        /*water properties: */
    57975797        IssmDouble rho_water;
     5798
     5799        /*exit now?:*/
     5800        this->parameters->FindParam(&computeelastic,SolidearthSettingsElasticEnum);
     5801        if(!computeelastic)return;
    57985802
    57995803        /*we are here to compute fingerprints originating fromn bottom pressure changes:*/

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

    r25508 r25627  
    165165                void    SetSealevelMasks(SealevelMasks* masks);
    166166                void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz);
    167                 void    SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);
    168                 void    SealevelriseEustaticIce(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);
    169                 void    SealevelriseEustaticHydro(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);
    170                 void    SealevelriseBottomPressure(IssmDouble* Sgi,SealevelMasks* masks);
     167                IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea);
     168                IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, IssmDouble oceanarea);
     169                void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks);
    171170                void    SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old,SealevelMasks* masks);
    172171                void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks);

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

    r25610 r25627  
    5353
    5454/*Object constructors and destructor*/
     55FemModel::FemModel(void){ /*{{{*/
     56        /*do nothing:*/
     57} /*}}}*/
    5558FemModel::FemModel(int argc,char** argv,ISSM_MPI_Comm incomm,bool trace){/*{{{*/
    5659
    … …  
    6669        char *restartfilename  = NULL;
    6770        char *rootpath       = NULL;
     71        char *modelname       = NULL;
    6872
    6973        /*First things first, store the communicator, and set it as a global variable: */
    … …  
    8185
    8286        /*From command line arguments, retrieve different filenames needed to create the FemModel: */
    83         ProcessArguments(&solution_type,&binfilename,&outbinfilename,&petscfilename,&lockfilename,&restartfilename,&rootpath,argc,argv);
     87        ProcessArguments(&solution_type,&binfilename,&outbinfilename,&petscfilename,&lockfilename,&restartfilename,&rootpath,&modelname,argc,argv);
    8488
    8589        /*Create femmodel from input files: */
    8690        profiler->Start(MPROCESSOR);
    87         this->InitFromFiles(rootpath,binfilename,outbinfilename,petscfilename,lockfilename,restartfilename, solution_type,trace,NULL);
     91        this->InitFromFiles(rootpath,binfilename,outbinfilename,petscfilename,lockfilename,restartfilename, modelname, solution_type,trace,NULL);
    8892        profiler->Stop(MPROCESSOR);
    8993
    … …  
    149153}
    150154/*}}}*/
    151 FemModel::FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, ISSM_MPI_Comm incomm, int solution_type,IssmPDouble* X){ /*{{{*/
     155FemModel::FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, char* modelname, ISSM_MPI_Comm incomm, int solution_type,IssmPDouble* X){ /*{{{*/
    152156
    153157        bool traceon=true;
    … …  
    160164        /*Create femmodel from input files, with trace activated: */
    161165        profiler->Start(MPROCESSOR);
    162         this->InitFromFiles(rootpath,inputfilename,outputfilename,toolkitsfilename,lockfilename,restartfilename, solution_type,traceon,X);
     166        this->InitFromFiles(rootpath,inputfilename,outputfilename,toolkitsfilename,lockfilename,restartfilename, modelname,solution_type,traceon,X);
    163167        profiler->Stop(MPROCESSOR);
    164168
    … …  
    418422}
    419423/*}}}*/
    420 void FemModel::InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, const int in_solution_type,bool trace,IssmPDouble* X){/*{{{*/
     424void FemModel::InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, char* modelname, const int in_solution_type,bool trace,IssmPDouble* X){/*{{{*/
    421425
    422426        /*intermediary*/
    … …  
    442446        /*Now save all of these file names into parameters, you never know when you might need them: */
    443447        this->parameters->AddObject(new StringParam(ToolkitsFileNameEnum,toolkitsfilename));
     448        this->parameters->AddObject(new StringParam(ModelnameEnum,modelname));
    444449        this->parameters->AddObject(new StringParam(RootPathEnum,rootpath));
    445450        this->parameters->AddObject(new StringParam(InputFileNameEnum,inputfilename));
    … …  
    47424747#endif
    47434748#ifdef _HAVE_SEALEVELRISE_
    4744 void FemModel::SealevelriseEustatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* peustatic, SealevelMasks* masks) { /*{{{*/
     4749void FemModel::SealevelriseEustatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, SealevelMasks* masks) { /*{{{*/
    47454750
    47464751        /*serialized vectors:*/
    4747         IssmDouble  eustatic       = 0.;
    4748         IssmDouble  eustatic_cpu   = 0.;
    4749         IssmDouble  eustatic_cpu_e = 0.;
     4752        IssmDouble  bslrice       = 0.;
     4753        IssmDouble  bslrice_cpu   = 0.;
     4754        IssmDouble  bslrhydro       = 0.;
     4755        IssmDouble  bslrhydro_cpu   = 0.;
    47504756        IssmDouble  area      = 0.;
    47514757        IssmDouble  oceanarea      = 0.;
    47524758        IssmDouble  oceanarea_cpu  = 0.;
     4759        int bp_compute_fingerprints= 0;
    47534760
    47544761   /*Initialize temporary vector that will be used to sum eustatic components
    … …  
    47714778        _assert_(oceanarea>0.);
    47724779
    4773         /*Call the sea level rise core: */
     4780        /*Call the sea level rise core for ice : */
     4781        bslrice_cpu=0;
    47744782        for(Object* & object : this->elements->objects){
    47754783                Element* element = xDynamicCast<Element*>(object);
    4776                 element->SealevelriseEustatic(RSLgi,&eustatic_cpu_e,masks, oceanarea);
    4777                 eustatic_cpu+=eustatic_cpu_e;
     4784                bslrice_cpu+=element->SealevelriseEustaticIce(RSLgi,masks, oceanarea);
     4785        }
     4786
     4787        /*Call the sea level rise core for hydro: */
     4788        bslrhydro_cpu=0;
     4789        for(int i=0;i<elements->Size();i++){
     4790                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4791                bslrhydro_cpu+=element->SealevelriseEustaticHydro(RSLgi,masks, oceanarea);
     4792        }
     4793
     4794        /*Call the sea level rise core for bottom pressures: */
     4795        this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
     4796        if(bp_compute_fingerprints){
     4797                for(int i=0;i<elements->Size();i++){
     4798                        Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4799                        element->SealevelriseEustaticBottomPressure(RSLgi,masks);
     4800                }
    47784801        }
    47794802
    … …  
    47834806
    47844807        /*Sum all eustatic components from all cpus:*/
    4785         ISSM_MPI_Reduce (&eustatic_cpu,&eustatic,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    4786         ISSM_MPI_Bcast(&eustatic,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
    4787         _assert_(!xIsNan<IssmDouble>(eustatic));
     4808        ISSM_MPI_Reduce (&bslrice_cpu,&bslrice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
     4809        ISSM_MPI_Bcast(&bslrice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
     4810        _assert_(!xIsNan<IssmDouble>(bslrice));
     4811
     4812        ISSM_MPI_Reduce (&bslrhydro_cpu,&bslrhydro,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
     4813        ISSM_MPI_Bcast(&bslrhydro,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
     4814        _assert_(!xIsNan<IssmDouble>(bslrhydro));
    47884815
    47894816        /*Free ressources:*/
    … …  
    47934820        /*Assign output pointers:*/
    47944821        *poceanarea = oceanarea;
    4795         *peustatic  = eustatic;
     4822        *pbslrice  = bslrice;
     4823        *pbslrhydro  = bslrhydro;
     4824        *pbslr=bslrhydro+bslrice;
    47964825
    47974826}

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

    r25508 r25627  
    6767
    6868                /*constructors, destructors: */
     69                FemModel(void);
    6970                FemModel(int argc,char** argv,ISSM_MPI_Comm comm_init,bool trace=false);
    70                 FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, ISSM_MPI_Comm incomm, int solution_type,IssmPDouble* X);
     71                FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, char* restartfilename, char* modelname, ISSM_MPI_Comm incomm, int solution_type,IssmPDouble* X);
    7172                ~FemModel();
    7273
    … …  
    7980                void Echo();
    8081                int  GetElementsWidth(){return 3;};//just tria elements in this first version
    81                 void InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* petscfilename, char* lockfilename, char* restartfilename, const int solution_type,bool trace,IssmPDouble* X=NULL);
     82                void InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* petscfilename, char* lockfilename, char* restartfilename, char* modelname, const int solution_type,bool trace,IssmPDouble* X=NULL);
    8283                void InitFromFids(char* rootpath, FILE* IOMODEL, FILE* toolkitsoptionsfid, int in_solution_type, bool trace, IssmPDouble* X=NULL);
    8384                void Marshall(MarshallHandle* marshallhandle);
    … …  
    165166                #endif
    166167                #ifdef _HAVE_SEALEVELRISE_
    167                 void SealevelriseEustatic(Vector<IssmDouble>* pSgi, IssmDouble* poceanarea, IssmDouble* peustatic, SealevelMasks* masks);
     168                void SealevelriseEustatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, SealevelMasks* masks);
    168169                void SealevelriseNonEustatic(Vector<IssmDouble>* pSgo, Vector<IssmDouble>* pSg_old,  SealevelMasks* masks,bool verboseconvolution);
    169170                void SealevelriseRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz, SealevelMasks* masks);

  • issm/trunk-jpl/src/c/cores/ProcessArguments.cpp

    r20939 r25627  
    88#include "../shared/shared.h"
    99
    10 void ProcessArguments(int* solution_type,char** pbinfilename,char** poutbinfilename,char** ptoolkitsfilename,char** plockfilename,char** prestartfilename, char** prootpath, int argc,char **argv){
     10void ProcessArguments(int* solution_type,char** pbinfilename,char** poutbinfilename,char** ptoolkitsfilename,char** plockfilename,char** prestartfilename, char** prootpath, char** pmodelname, int argc,char **argv){
    1111
    1212        /*Check input arguments*/
    … …  
    1818        *solution_type = StringToEnumx(argv[1]);
    1919        char* rootpatharg = argv[2];
    20         char* modelname   = argv[3];
     20        char* modelname      = xNew<char>(strlen(argv[3])+1);
     21        xMemCpy<char>(modelname,argv[3],strlen(argv[3])+1);
    2122
    2223        /*Recover myrank and length of string "my_rank" */
    … …  
    4243        *prestartfilename=restartfilename;
    4344        *prootpath=rootpath;
     45        *pmodelname=modelname;
    4446
    4547}

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

    r25465 r25627  
    7373
    7474//diverse
    75 void ProcessArguments(int* solution,char** pbinname,char** poutbinname,char** ptoolkitsname,char** plockname,char** prestartname, char** prootpath,int argc,char **argv);
     75void ProcessArguments(int* solution,char** pbinname,char** poutbinname,char** ptoolkitsname,char** plockname,char** prestartname, char** prootpath,char** pmodelname, int argc,char **argv);
    7676void WriteLockFile(char* filename);
    7777void ResetBoundaryConditions(FemModel* femmodel, int analysis_type);

  • issm/trunk-jpl/src/c/cores/sealevelchange_core.cpp

    r25539 r25627  
    268268        IssmDouble          dt;
    269269        int  geodetic=0;
     270        int  step;
     271        IssmDouble time;
     272        IssmDouble cumgmtslr=0;
     273        IssmDouble cumbslr=0;
     274        IssmDouble cumgmslr=0;
     275        IssmDouble gmtslr=0;
    270276
    271277        /*Retrieve parameters:*/
    … …  
    274280        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    275281        femmodel->parameters->FindParam(&geodetic,SolidearthSettingsComputesealevelchangeEnum);
     282        femmodel->parameters->FindParam(&cumgmtslr,CumGmtslrEnum);
     283        femmodel->parameters->FindParam(&cumbslr,CumBslrEnum);
     284        femmodel->parameters->FindParam(&step,StepEnum);
     285        femmodel->parameters->FindParam(&time,TimeEnum);
    276286
    277287        /*in case we are running SealevelriseSolutionEnum, then bypass transient settings:*/
    … …  
    296306        }
    297307
     308        /*Save steric rate, and cumulate it through time, cumulate with barystatic sea level rise, and cumulate through time:*/
     309        gmtslr=steric_rate_g->Max()*dt;
     310        cumgmtslr+=gmtslr;
     311        cumgmslr=cumbslr+cumgmtslr;
     312        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,GmtslrEnum,gmtslr,step,time));
     313        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmtslrEnum,cumgmtslr,step,time));
     314        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmslrEnum,cumgmslr,step,time));
     315        femmodel->parameters->SetParam(cumgmtslr,CumGmtslrEnum);
     316
    298317        /*compute: sea level change = initial sea level + (N_gia_rate+N_esa_rate)  * dt + steric_rate + dynamic_rate dt*/
    299318        if(geodetic){
    … …  
    376395
    377396
    378         /*Run sealevelrie geometry routine in elements:*/
     397        /*Run sealevelrise geometry routine in elements:*/
    379398        for(Object* & object : femmodel->elements->objects){
    380399                Element*   element=xDynamicCast<Element*>(object);
    … …  
    410429        IssmDouble time;
    411430
    412         /*outputs:*/
    413         IssmDouble eustatic;
     431        /*barystatic contribution:*/
     432        IssmDouble bslr;
     433        IssmDouble bslrice;
     434        IssmDouble bslrhydro;
     435        IssmDouble cumbslr;
     436        IssmDouble cumbslrice;
     437        IssmDouble cumbslrhydro;
    414438       
    415         if(VerboseSolution()) _printf0_("         computing eustatic components on ice\n");
    416 
    417        
     439        if(VerboseSolution()) _printf0_("         computing bslr components on ice\n");
     440
    418441        /*Figure out size of g-set deflection vector and allocate solution vector: */
    419442        gsize = femmodel->nodes->NumberOfDofs(GsetEnum);
    … …  
    422445        femmodel->parameters->FindParam(&step,StepEnum);
    423446        femmodel->parameters->FindParam(&time,TimeEnum);
     447        femmodel->parameters->FindParam(&cumbslr,CumBslrEnum);
     448        femmodel->parameters->FindParam(&cumbslrice,CumBslrIceEnum);
     449        femmodel->parameters->FindParam(&cumbslrhydro,CumBslrHydroEnum);
    424450
    425451        /*Initialize:*/
    426452        RSLgi = new Vector<IssmDouble>(gsize);
    427453
    428         /*call the eustatic main module: */
    429         femmodel->SealevelriseEustatic(RSLgi,&oceanarea,&eustatic, masks); //this computes
     454        /*call the bslr main module: */
     455        femmodel->SealevelriseEustatic(RSLgi,&oceanarea,&bslr, &bslrice, &bslrhydro, masks); //this computes
    430456
    431457        /*we need to average RSLgi over the ocean: RHS term  4 in Eq.4 of Farrel and clarke. Only the elements can do that: */
    432458        RSLgi_oceanaverage=femmodel->SealevelriseOceanAverage(RSLgi,masks, oceanarea);
    433459
    434         /*RSLg is the sum of the pure eustatic component (term 3) and the contribution from the perturbation to the graviation potential due to the
     460        /*RSLg is the sum of the pure bslr component (term 3) and the contribution from the perturbation to the graviation potential due to the
    435461         * presence of ice (terms 1 and 4 in Eq.4 of Farrel and Clarke):*/
    436         RSLgi->Shift(-eustatic-RSLgi_oceanaverage);
    437 
    438         /*save eustatic value for results: */
    439         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,SealevelRSLEustaticEnum,-eustatic,step,time));
    440 
     462        RSLgi->Shift(-bslr-RSLgi_oceanaverage);
     463
     464        /*save bslr and cumulated bslr value for results:{{{ */
     465        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrEnum,-bslr,step,time));
     466        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrIceEnum,-bslrice,step,time));
     467        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrHydroEnum,-bslrhydro,step,time));
     468
     469        cumbslr=cumbslr-bslr;
     470        cumbslrice=cumbslrice-bslrice;
     471        cumbslrhydro=cumbslrhydro-bslrhydro;
     472        femmodel->parameters->SetParam(cumbslr,CumBslrEnum);
     473        femmodel->parameters->SetParam(cumbslrice,CumBslrIceEnum);
     474        femmodel->parameters->SetParam(cumbslrhydro,CumBslrHydroEnum);
     475
     476        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrEnum,cumbslr,step,time));
     477        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrIceEnum,cumbslrice,step,time));
     478        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrHydroEnum,cumbslrhydro,step,time));
     479        /*}}}*/
     480       
    441481        /*Assign output pointers and return: */
    442482        *poceanarea=oceanarea;
    … …  
    465505        IssmDouble           eps_rel;
    466506        IssmDouble           eps_abs;
    467         IssmDouble           eustatic;
    468507        IssmDouble                      Ixz, Iyz, Izz;
    469508       

  • issm/trunk-jpl/src/c/main/issm_dakota.cpp

    r23066 r25627  
    1414#endif
    1515
    16 int main(int argc,char **argv){
     16int main(int argc,char **argv){ /*{{{*/
    1717
    1818        #if defined(_HAVE_DAKOTA_) && _DAKOTA_MAJOR_ >= 6
    … …  
    2222        char* dakota_output_file = NULL;
    2323        char* dakota_error_file = NULL;
     24        bool statistics=false;
    2425
    2526        /*Define MPI_DEBUG in dakota_global_defs.cpp to cause a hold here*/
    … …  
    3839        dakota_error_file=xNew<char>((strlen(argv[2])+strlen(argv[3])+strlen(".qmu.err")+2));
    3940        sprintf(dakota_error_file,"%s/%s%s",argv[2],argv[3],".qmu.err");
     41
     42        /*Create directory structure for model outputs:*/
     43        statistics=DakotaDirStructure(argc,argv);
    4044
    4145        /* Parse input and construct Dakota LibraryEnvironment, performing input data checks*/
    … …  
    8387        env.execute();
    8488
     89        /* Run statistics if requested:*/
     90        if(statistics)DakotaStatistics(argc,argv);
     91
     92        /*free allocations:*/
    8593        xDelete<char>(dakota_input_file);
    8694        xDelete<char>(dakota_output_file);
    … …  
    94102        #endif
    95103
    96 }
     104} /*}}}*/

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

    r25539 r25627  
    88#include "./ModelProcessorx.h"
    99
    10 #define MAXCONNECTIVITY 5
     10#define MAXCONNECTIVITY 15
    1111
    1212bool IsVertexInRank(int* vertices_ranks,int* vertices_proc_count,int vid,int rank){/*{{{*/

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

    r25514 r25627  
    99#include "./ModelProcessorx.h"
    1010
    11 #define MAXCONNECTIVITY 5
     11#define MAXCONNECTIVITY 15
    1212
    1313bool IsNodeInRank(int* nodes_ranks,int* nodes_proc_count,int nid,int rank){/*{{{*/

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

    r25257 r25627  
    4141        int M,N;
    4242
     43        //qmu statistics
     44        bool statistics    = false;
     45        int  numdirectories = 0;
     46        int  nfilesperdirectory = 0;
     47
    4348        /*recover parameters: */
    4449        iomodel->FindConstant(&dakota_analysis,"md.qmu.isdakota");
    … …  
    7277                /*Ok, we have all the response descriptors. Build a parameter with it: */
    7378                parameters->AddObject(new StringArrayParam(QmuResponsedescriptorsEnum,responsedescriptors,numresponsedescriptors));
     79
     80                /*Deal with statistics: */
     81                iomodel->FindConstant(&statistics,"md.qmu.statistics");
     82                parameters->AddObject(new BoolParam(QmuStatisticsEnum,statistics));
     83                if(statistics){
     84                        iomodel->FindConstant(&numdirectories,"md.qmu.statistics.ndirectories");
     85                        parameters->AddObject(new IntParam(QmuNdirectoriesEnum,numdirectories));
     86
     87                        iomodel->FindConstant(&nfilesperdirectory,"md.qmu.statistics.nfiles_per_directory");
     88                        parameters->AddObject(new IntParam(QmuNfilesPerDirectoryEnum,nfilesperdirectory));
     89                }
    7490
    7591                /*Load partitioning vectors specific to variables:*/
    … …  
    109125                /*}}}*/
    110126
    111 
    112127                /*Deal with data needed because of qmu variables*/
    113128                DataSet* dataset_variable_descriptors = new DataSet(QmuVariableDescriptorsEnum);
    … …  
    143158                delete dataset_variable_descriptors;
    144159
    145                 /*clean-up*/
     160                /*clean-up {{{*/
    146161                for(i=0;i<numresponsedescriptors;i++){
    147162                        descriptor=responsedescriptors[i];
    … …  
    157172                xDelete<char>(qmuerrname);
    158173                xDelete<char>(qmuoutname);
    159 
    160                
    161                
     174                xDelete<char>(name);
     175                /*}}}*/
    162176        }
    163177
    164         /*Free data*/
    165         xDelete<char>(name);
    166178}

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

    r14999 r25627  
    1919
    2020        int i,j,n;
    21         const int maxels=50;
     21        const int maxels=100;
    2222        const int width=maxels+1;
    2323

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

    r25334 r25627  
    6363                else{
    6464                        if(my_rank==0){
     65                                /*a little bit complicated. Either statistic computations are requested, which means we
     66                                 * put our outbin files in subidirectories with numbers, or we don't, and we dump our
     67                                 * outbins directly in the current directory:*/
    6568                                int currEvalId ;
     69                                int nfilesperdirectory;
     70                                bool statistics=false;
     71                                char* root=NULL;
     72                                char* modelname=NULL;
     73                               
    6674                                femmodel->parameters->FindParam(&currEvalId,QmuCurrEvalIdEnum);
    67                                 sprintf(outputfilename2,"%s.%i",outputfilename,currEvalId);
     75                                femmodel->parameters->FindParam(&statistics,QmuStatisticsEnum);
     76
     77                                if(statistics){
     78                                        femmodel->parameters->FindParam(&nfilesperdirectory,QmuNfilesPerDirectoryEnum);
     79                                        femmodel->parameters->FindParam(&root,RootPathEnum);
     80                                        femmodel->parameters->FindParam(&modelname,ModelnameEnum);
     81                                        sprintf(outputfilename2,"%s/%i/%s.outbin.%i",root,(int)(floor((currEvalId-1)/nfilesperdirectory)+1),modelname,currEvalId);
     82                                }
     83                                else{
     84                                        sprintf(outputfilename2,"%s.%i",outputfilename,currEvalId);
     85                                }
    6886                                fid=pfopen0(outputfilename2,"ab+");
    6987                        }

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

    r23992 r25627  
    8181#include "./PointCloudFindNeighborsx/PointCloudFindNeighborsx.h"
    8282#include "./PropagateFlagsFromConnectivityx/PropagateFlagsFromConnectivityx.h"
     83#include "./QmuStatisticsx/QmuStatisticsx.h"
    8384#include "./Reduceloadx/Reduceloadx.h"
    8485#include "./Reducevectorgtofx/Reducevectorgtofx.h"

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

    r25609 r25627  
    112112syn keyword cConstant ControlInputSizeNEnum
    113113syn keyword cConstant ControlInputInterpolationEnum
     114syn keyword cConstant CumBslrEnum
     115syn keyword cConstant CumBslrIceEnum
     116syn keyword cConstant CumBslrHydroEnum
     117syn keyword cConstant CumGmtslrEnum
     118syn keyword cConstant CumGmslrEnum
    114119syn keyword cConstant DamageC1Enum
    115120syn keyword cConstant DamageC2Enum
    … …  
    142147syn keyword cConstant ExtrapolationVariableEnum
    143148syn keyword cConstant FemModelCommEnum
     149syn keyword cConstant FieldsEnum
    144150syn keyword cConstant FlowequationFeFSEnum
    145151syn keyword cConstant FlowequationIsFSEnum
    … …  
    211217syn keyword cConstant IndexEnum
    212218syn keyword cConstant InputFileNameEnum
     219syn keyword cConstant DirectoryNameEnum
     220syn keyword cConstant IndicesEnum
    213221syn keyword cConstant InputToDepthaverageInEnum
    214222syn keyword cConstant InputToDepthaverageOutEnum
    … …  
    283291syn keyword cConstant MeshNumberofverticesEnum
    284292syn keyword cConstant ModelIdEnum
     293syn keyword cConstant NbinsEnum
    285294syn keyword cConstant NodesEnum
    286295syn keyword cConstant NumModelsEnum
    … …  
    300309syn keyword cConstant QmuOutputEnum
    301310syn keyword cConstant QmuCurrEvalIdEnum
     311syn keyword cConstant QmuNsampleEnum
    302312syn keyword cConstant QmuResponsedescriptorsEnum
    303313syn keyword cConstant QmuVariableDescriptorsEnum
    … …  
    307317syn keyword cConstant QmuResponsePartitionsEnum
    308318syn keyword cConstant QmuResponsePartitionsNpartEnum
     319syn keyword cConstant QmuStatisticsEnum
     320syn keyword cConstant QmuNumstatisticsEnum
     321syn keyword cConstant QmuNdirectoriesEnum
     322syn keyword cConstant QmuNfilesPerDirectoryEnum
     323syn keyword cConstant QmuStatisticsMethodEnum
     324syn keyword cConstant QmuMethodsEnum
    309325syn keyword cConstant RestartFileNameEnum
    310326syn keyword cConstant ResultsEnum
    311327syn keyword cConstant RootPathEnum
     328syn keyword cConstant ModelnameEnum
    312329syn keyword cConstant SaveResultsEnum
    313330syn keyword cConstant SolidearthPlanetRadiusEnum
    314331syn keyword cConstant SolidearthPlanetAreaEnum
    315 syn keyword cConstant SealevelEustaticEnum
    316332syn keyword cConstant SolidearthSettingsAbstolEnum
    317333syn keyword cConstant RotationalAngularVelocityEnum
    … …  
    412428syn keyword cConstant SteadystateRequestedOutputsEnum
    413429syn keyword cConstant StepEnum
     430syn keyword cConstant StepsEnum
    414431syn keyword cConstant StressbalanceAbstolEnum
    415432syn keyword cConstant StressbalanceFSreconditioningEnum
    … …  
    688705syn keyword cConstant SealevelNEsaRateEnum
    689706syn keyword cConstant SealevelRSLEnum
     707syn keyword cConstant BslrEnum
     708syn keyword cConstant BslrIceEnum
     709syn keyword cConstant BslrHydroEnum
     710syn keyword cConstant BslrRateEnum
     711syn keyword cConstant GmtslrEnum
    690712syn keyword cConstant SealevelRSLEustaticEnum
    691713syn keyword cConstant SealevelRSLEustaticRateEnum
    … …  
    12821304syn keyword cConstant SpcTransientEnum
    12831305syn keyword cConstant SsetEnum
     1306syn keyword cConstant StatisticsSolutionEnum
    12841307syn keyword cConstant SteadystateSolutionEnum
    12851308syn keyword cConstant StressIntensityFactorEnum
    … …  
    13601383syn keyword cType Cfsurfacesquare
    13611384syn keyword cType Channel
    1362 syn keyword cType classes
    13631385syn keyword cType Constraint
    13641386syn keyword cType Constraints
    … …  
    13671389syn keyword cType ControlInput
    13681390syn keyword cType Covertree
     1391syn keyword cType DataSetParam
    13691392syn keyword cType DatasetInput
    1370 syn keyword cType DataSetParam
    13711393syn keyword cType Definition
    13721394syn keyword cType DependentObject
    … …  
    13811403syn keyword cType ElementInput
    13821404syn keyword cType ElementMatrix
     1405syn keyword cType ElementVector
    13831406syn keyword cType Elements
    1384 syn keyword cType ElementVector
    13851407syn keyword cType ExponentialVariogram
    13861408syn keyword cType ExternalResult
    … …  
    13891411syn keyword cType Friction
    13901412syn keyword cType Gauss
    1391 syn keyword cType GaussianVariogram
    1392 syn keyword cType gaussobjects
    13931413syn keyword cType GaussPenta
    13941414syn keyword cType GaussSeg
    13951415syn keyword cType GaussTetra
    13961416syn keyword cType GaussTria
     1417syn keyword cType GaussianVariogram
    13971418syn keyword cType GenericExternalResult
    13981419syn keyword cType GenericOption
    … …  
    14091430syn keyword cType IssmDirectApplicInterface
    14101431syn keyword cType IssmParallelDirectApplicInterface
    1411 syn keyword cType krigingobjects
    14121432syn keyword cType Load
    14131433syn keyword cType Loads
    … …  
    14201440syn keyword cType Matice
    14211441syn keyword cType Matlitho
    1422 syn keyword cType matrixobjects
    14231442syn keyword cType MatrixParam
    14241443syn keyword cType Misfit
    … …  
    14331452syn keyword cType Observations
    14341453syn keyword cType Option
     1454syn keyword cType OptionUtilities
    14351455syn keyword cType Options
    1436 syn keyword cType OptionUtilities
    14371456syn keyword cType Param
    14381457syn keyword cType Parameters
    … …  
    14481467syn keyword cType Regionaloutput
    14491468syn keyword cType Results
     1469syn keyword cType RiftStruct
    14501470syn keyword cType Riftfront
    1451 syn keyword cType RiftStruct
    14521471syn keyword cType SealevelMasks
    14531472syn keyword cType Seg
    14541473syn keyword cType SegInput
     1474syn keyword cType SegRef
    14551475syn keyword cType Segment
    1456 syn keyword cType SegRef
    14571476syn keyword cType SpcDynamic
    14581477syn keyword cType SpcStatic
    … …  
    14731492syn keyword cType Vertex
    14741493syn keyword cType Vertices
     1494syn keyword cType classes
     1495syn keyword cType gaussobjects
     1496syn keyword cType krigingobjects
     1497syn keyword cType matrixobjects
    14751498syn keyword cType AdjointBalancethickness2Analysis
    14761499syn keyword cType AdjointBalancethicknessAnalysis
    … …  
    14911514syn keyword cType FreeSurfaceBaseAnalysis
    14921515syn keyword cType FreeSurfaceTopAnalysis
     1516syn keyword cType GLheightadvectionAnalysis
    14931517syn keyword cType GiaAnalysis
    1494 syn keyword cType GLheightadvectionAnalysis
    14951518syn keyword cType HydrologyDCEfficientAnalysis
    14961519syn keyword cType HydrologyDCInefficientAnalysis

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

    r25609 r25627  
    106106        ControlInputSizeNEnum,
    107107        ControlInputInterpolationEnum,
     108        CumBslrEnum,
     109        CumBslrIceEnum,
     110        CumBslrHydroEnum,
     111        CumGmtslrEnum,
     112        CumGmslrEnum,
    108113        DamageC1Enum,
    109114        DamageC2Enum,
    … …  
    136141        ExtrapolationVariableEnum,
    137142        FemModelCommEnum,
     143        FieldsEnum,
    138144        FlowequationFeFSEnum,
    139145        FlowequationIsFSEnum,
    … …  
    205211        IndexEnum,
    206212        InputFileNameEnum,
     213        DirectoryNameEnum,
     214        IndicesEnum,
    207215        InputToDepthaverageInEnum,
    208216        InputToDepthaverageOutEnum,
    … …  
    277285        MeshNumberofverticesEnum,
    278286        ModelIdEnum,
     287        NbinsEnum,
    279288        NodesEnum,
    280289        NumModelsEnum,
    … …  
    294303        QmuOutputEnum,
    295304        QmuCurrEvalIdEnum,
     305        QmuNsampleEnum,
    296306        QmuResponsedescriptorsEnum,
    297307        QmuVariableDescriptorsEnum,
    … …  
    301311        QmuResponsePartitionsEnum,
    302312        QmuResponsePartitionsNpartEnum,
     313        QmuStatisticsEnum,
     314        QmuNumstatisticsEnum,
     315        QmuNdirectoriesEnum,
     316        QmuNfilesPerDirectoryEnum,
     317        QmuStatisticsMethodEnum,
     318        QmuMethodsEnum,
    303319        RestartFileNameEnum,
    304320        ResultsEnum,
    305321        RootPathEnum,
     322        ModelnameEnum,
    306323        SaveResultsEnum,
    307324        SolidearthPlanetRadiusEnum,
    308325        SolidearthPlanetAreaEnum,
    309         SealevelEustaticEnum,
    310326        SolidearthSettingsAbstolEnum,
    311327        RotationalAngularVelocityEnum,
    … …  
    406422        SteadystateRequestedOutputsEnum,
    407423        StepEnum,
     424        StepsEnum,
    408425        StressbalanceAbstolEnum,
    409426        StressbalanceFSreconditioningEnum,
    … …  
    684701        SealevelNEsaRateEnum,
    685702        SealevelRSLEnum,
     703        BslrEnum,
     704        BslrIceEnum,
     705        BslrHydroEnum,
     706        BslrRateEnum,
     707        GmtslrEnum,
    686708        SealevelRSLEustaticEnum,
    687709        SealevelRSLEustaticRateEnum,
    … …  
    12811303        SpcTransientEnum,
    12821304        SsetEnum,
     1305        StatisticsSolutionEnum,
    12831306        SteadystateSolutionEnum,
    12841307        StressIntensityFactorEnum,

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

    r25609 r25627  
    114114                case ControlInputSizeNEnum : return "ControlInputSizeN";
    115115                case ControlInputInterpolationEnum : return "ControlInputInterpolation";
     116                case CumBslrEnum : return "CumBslr";
     117                case CumBslrIceEnum : return "CumBslrIce";
     118                case CumBslrHydroEnum : return "CumBslrHydro";
     119                case CumGmtslrEnum : return "CumGmtslr";
     120                case CumGmslrEnum : return "CumGmslr";
    116121                case DamageC1Enum : return "DamageC1";
    117122                case DamageC2Enum : return "DamageC2";
    … …  
    144149                case ExtrapolationVariableEnum : return "ExtrapolationVariable";
    145150                case FemModelCommEnum : return "FemModelComm";
     151                case FieldsEnum : return "Fields";
    146152                case FlowequationFeFSEnum : return "FlowequationFeFS";
    147153                case FlowequationIsFSEnum : return "FlowequationIsFS";
    … …  
    213219                case IndexEnum : return "Index";
    214220                case InputFileNameEnum : return "InputFileName";
     221                case DirectoryNameEnum : return "DirectoryName";
     222                case IndicesEnum : return "Indices";
    215223                case InputToDepthaverageInEnum : return "InputToDepthaverageIn";
    216224                case InputToDepthaverageOutEnum : return "InputToDepthaverageOut";
    … …  
    285293                case MeshNumberofverticesEnum : return "MeshNumberofvertices";
    286294                case ModelIdEnum : return "ModelId";
     295                case NbinsEnum : return "Nbins";
    287296                case NodesEnum : return "Nodes";
    288297                case NumModelsEnum : return "NumModels";
    … …  
    302311                case QmuOutputEnum : return "QmuOutput";
    303312                case QmuCurrEvalIdEnum : return "QmuCurrEvalId";
     313                case QmuNsampleEnum : return "QmuNsample";
    304314                case QmuResponsedescriptorsEnum : return "QmuResponsedescriptors";
    305315                case QmuVariableDescriptorsEnum : return "QmuVariableDescriptors";
    … …  
    309319                case QmuResponsePartitionsEnum : return "QmuResponsePartitions";
    310320                case QmuResponsePartitionsNpartEnum : return "QmuResponsePartitionsNpart";
     321                case QmuStatisticsEnum : return "QmuStatistics";
     322                case QmuNumstatisticsEnum : return "QmuNumstatistics";
     323                case QmuNdirectoriesEnum : return "QmuNdirectories";
     324                case QmuNfilesPerDirectoryEnum : return "QmuNfilesPerDirectory";
     325                case QmuStatisticsMethodEnum : return "QmuStatisticsMethod";
     326                case QmuMethodsEnum : return "QmuMethods";
    311327                case RestartFileNameEnum : return "RestartFileName";
    312328                case ResultsEnum : return "Results";
    313329                case RootPathEnum : return "RootPath";
     330                case ModelnameEnum : return "Modelname";
    314331                case SaveResultsEnum : return "SaveResults";
    315332                case SolidearthPlanetRadiusEnum : return "SolidearthPlanetRadius";
    316333                case SolidearthPlanetAreaEnum : return "SolidearthPlanetArea";
    317                 case SealevelEustaticEnum : return "SealevelEustatic";
    318334                case SolidearthSettingsAbstolEnum : return "SolidearthSettingsAbstol";
    319335                case RotationalAngularVelocityEnum : return "RotationalAngularVelocity";
    … …  
    414430                case SteadystateRequestedOutputsEnum : return "SteadystateRequestedOutputs";
    415431                case StepEnum : return "Step";
     432                case StepsEnum : return "Steps";
    416433                case StressbalanceAbstolEnum : return "StressbalanceAbstol";
    417434                case StressbalanceFSreconditioningEnum : return "StressbalanceFSreconditioning";
    … …  
    690707                case SealevelNEsaRateEnum : return "SealevelNEsaRate";
    691708                case SealevelRSLEnum : return "SealevelRSL";
     709                case BslrEnum : return "Bslr";
     710                case BslrIceEnum : return "BslrIce";
     711                case BslrHydroEnum : return "BslrHydro";
     712                case BslrRateEnum : return "BslrRate";
     713                case GmtslrEnum : return "Gmtslr";
    692714                case SealevelRSLEustaticEnum : return "SealevelRSLEustatic";
    693715                case SealevelRSLEustaticRateEnum : return "SealevelRSLEustaticRate";
    … …  
    12841306                case SpcTransientEnum : return "SpcTransient";
    12851307                case SsetEnum : return "Sset";
     1308                case StatisticsSolutionEnum : return "StatisticsSolution";
    12861309                case SteadystateSolutionEnum : return "SteadystateSolution";
    12871310                case StressIntensityFactorEnum : return "StressIntensityFactor";

  • issm/trunk-jpl/src/c/shared/Enum/README

    r21074 r25627  
    1 
    21DO NOT MODIFY the following files:
    32- StringToEnumx.cpp
    … …  
    65
    76TO ADD AN ENUM:
    8 add the corresponding lines to EnumDefinitions.h
    9 and execute synchronizing script.
     7- add the desired, new Enums to EnumDefinitions.h
     8- execute `./Synchronize.sh`
     9
     10NOTE:   Even when Synchronize.sh is run from this directory, ISSM_DIR must be
     11                defined correctly

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

    r25609 r25627  
    114114              else if (strcmp(name,"ControlInputSizeN")==0) return ControlInputSizeNEnum;
    115115              else if (strcmp(name,"ControlInputInterpolation")==0) return ControlInputInterpolationEnum;
     116              else if (strcmp(name,"CumBslr")==0) return CumBslrEnum;
     117              else if (strcmp(name,"CumBslrIce")==0) return CumBslrIceEnum;
     118              else if (strcmp(name,"CumBslrHydro")==0) return CumBslrHydroEnum;
     119              else if (strcmp(name,"CumGmtslr")==0) return CumGmtslrEnum;
     120              else if (strcmp(name,"CumGmslr")==0) return CumGmslrEnum;
    116121              else if (strcmp(name,"DamageC1")==0) return DamageC1Enum;
    117122              else if (strcmp(name,"DamageC2")==0) return DamageC2Enum;
    … …  
    132137              else if (strcmp(name,"DomainDimension")==0) return DomainDimensionEnum;
    133138              else if (strcmp(name,"DomainType")==0) return DomainTypeEnum;
    134               else if (strcmp(name,"DslModel")==0) return DslModelEnum;
     139         else stage=2;
     140   }
     141   if(stage==2){
     142              if (strcmp(name,"DslModel")==0) return DslModelEnum;
    135143              else if (strcmp(name,"DslModelid")==0) return DslModelidEnum;
    136144              else if (strcmp(name,"DslNummodels")==0) return DslNummodelsEnum;
    137145              else if (strcmp(name,"DslComputeFingerprints")==0) return DslComputeFingerprintsEnum;
    138146              else if (strcmp(name,"EarthId")==0) return EarthIdEnum;
    139          else stage=2;
    140    }
    141    if(stage==2){
    142               if (strcmp(name,"EplZigZagCounter")==0) return EplZigZagCounterEnum;
     147              else if (strcmp(name,"EplZigZagCounter")==0) return EplZigZagCounterEnum;
    143148              else if (strcmp(name,"EsaHElastic")==0) return EsaHElasticEnum;
    144149              else if (strcmp(name,"EsaHemisphere")==0) return EsaHemisphereEnum;
    … …  
    147152              else if (strcmp(name,"ExtrapolationVariable")==0) return ExtrapolationVariableEnum;
    148153              else if (strcmp(name,"FemModelComm")==0) return FemModelCommEnum;
     154              else if (strcmp(name,"Fields")==0) return FieldsEnum;
    149155              else if (strcmp(name,"FlowequationFeFS")==0) return FlowequationFeFSEnum;
    150156              else if (strcmp(name,"FlowequationIsFS")==0) return FlowequationIsFSEnum;
    … …  
    216222              else if (strcmp(name,"Index")==0) return IndexEnum;
    217223              else if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
     224              else if (strcmp(name,"DirectoryName")==0) return DirectoryNameEnum;
     225              else if (strcmp(name,"Indices")==0) return IndicesEnum;
    218226              else if (strcmp(name,"InputToDepthaverageIn")==0) return InputToDepthaverageInEnum;
    219227              else if (strcmp(name,"InputToDepthaverageOut")==0) return InputToDepthaverageOutEnum;
    … …  
    252260              else if (strcmp(name,"LoveNfreq")==0) return LoveNfreqEnum;
    253261              else if (strcmp(name,"LoveR0")==0) return LoveR0Enum;
    254               else if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
     262         else stage=3;
     263   }
     264   if(stage==3){
     265              if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
    255266              else if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum;
    256267              else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum;
    … …  
    260271              else if (strcmp(name,"MasstransportMinThickness")==0) return MasstransportMinThicknessEnum;
    261272              else if (strcmp(name,"MasstransportNumRequestedOutputs")==0) return MasstransportNumRequestedOutputsEnum;
    262          else stage=3;
    263    }
    264    if(stage==3){
    265               if (strcmp(name,"MasstransportPenaltyFactor")==0) return MasstransportPenaltyFactorEnum;
     273              else if (strcmp(name,"MasstransportPenaltyFactor")==0) return MasstransportPenaltyFactorEnum;
    266274              else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum;
    267275              else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum;
    … …  
    291299              else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum;
    292300              else if (strcmp(name,"ModelId")==0) return ModelIdEnum;
     301              else if (strcmp(name,"Nbins")==0) return NbinsEnum;
    293302              else if (strcmp(name,"Nodes")==0) return NodesEnum;
    294303              else if (strcmp(name,"NumModels")==0) return NumModelsEnum;
    … …  
    308317              else if (strcmp(name,"QmuOutput")==0) return QmuOutputEnum;
    309318              else if (strcmp(name,"QmuCurrEvalId")==0) return QmuCurrEvalIdEnum;
     319              else if (strcmp(name,"QmuNsample")==0) return QmuNsampleEnum;
    310320              else if (strcmp(name,"QmuResponsedescriptors")==0) return QmuResponsedescriptorsEnum;
    311321              else if (strcmp(name,"QmuVariableDescriptors")==0) return QmuVariableDescriptorsEnum;
    … …  
    315325              else if (strcmp(name,"QmuResponsePartitions")==0) return QmuResponsePartitionsEnum;
    316326              else if (strcmp(name,"QmuResponsePartitionsNpart")==0) return QmuResponsePartitionsNpartEnum;
     327              else if (strcmp(name,"QmuStatistics")==0) return QmuStatisticsEnum;
     328              else if (strcmp(name,"QmuNumstatistics")==0) return QmuNumstatisticsEnum;
     329              else if (strcmp(name,"QmuNdirectories")==0) return QmuNdirectoriesEnum;
     330              else if (strcmp(name,"QmuNfilesPerDirectory")==0) return QmuNfilesPerDirectoryEnum;
     331              else if (strcmp(name,"QmuStatisticsMethod")==0) return QmuStatisticsMethodEnum;
     332              else if (strcmp(name,"QmuMethods")==0) return QmuMethodsEnum;
    317333              else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum;
    318334              else if (strcmp(name,"Results")==0) return ResultsEnum;
    319335              else if (strcmp(name,"RootPath")==0) return RootPathEnum;
     336              else if (strcmp(name,"Modelname")==0) return ModelnameEnum;
    320337              else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum;
    321338              else if (strcmp(name,"SolidearthPlanetRadius")==0) return SolidearthPlanetRadiusEnum;
    322339              else if (strcmp(name,"SolidearthPlanetArea")==0) return SolidearthPlanetAreaEnum;
    323               else if (strcmp(name,"SealevelEustatic")==0) return SealevelEustaticEnum;
    324340              else if (strcmp(name,"SolidearthSettingsAbstol")==0) return SolidearthSettingsAbstolEnum;
    325341              else if (strcmp(name,"RotationalAngularVelocity")==0) return RotationalAngularVelocityEnum;
    … …  
    367383              else if (strcmp(name,"SmbAveraging")==0) return SmbAveragingEnum;
    368384              else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
    369               else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
     385         else stage=4;
     386   }
     387   if(stage==4){
     388              if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
    370389              else if (strcmp(name,"SmbDsnowIdx")==0) return SmbDsnowIdxEnum;
    371390              else if (strcmp(name,"SmbCldFrac")==0) return SmbCldFracEnum;
    … …  
    383402              else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum;
    384403              else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum;
    385          else stage=4;
    386    }
    387    if(stage==4){
    388               if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum;
     404              else if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum;
    389405              else if (strcmp(name,"SmbIsfirnwarming")==0) return SmbIsfirnwarmingEnum;
    390406              else if (strcmp(name,"SmbIsgraingrowth")==0) return SmbIsgraingrowthEnum;
    … …  
    423439              else if (strcmp(name,"SteadystateRequestedOutputs")==0) return SteadystateRequestedOutputsEnum;
    424440              else if (strcmp(name,"Step")==0) return StepEnum;
     441              else if (strcmp(name,"Steps")==0) return StepsEnum;
    425442              else if (strcmp(name,"StressbalanceAbstol")==0) return StressbalanceAbstolEnum;
    426443              else if (strcmp(name,"StressbalanceFSreconditioning")==0) return StressbalanceFSreconditioningEnum;
    … …  
    489506              else if (strcmp(name,"Approximation")==0) return ApproximationEnum;
    490507              else if (strcmp(name,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum;
    491               else if (strcmp(name,"BalancethicknessOmega0")==0) return BalancethicknessOmega0Enum;
     508         else stage=5;
     509   }
     510   if(stage==5){
     511              if (strcmp(name,"BalancethicknessOmega0")==0) return BalancethicknessOmega0Enum;
    492512              else if (strcmp(name,"BalancethicknessOmega")==0) return BalancethicknessOmegaEnum;
    493513              else if (strcmp(name,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum;
    … …  
    506526              else if (strcmp(name,"BasalforcingsPicoBasinId")==0) return BasalforcingsPicoBasinIdEnum;
    507527              else if (strcmp(name,"BasalforcingsPicoBoxId")==0) return BasalforcingsPicoBoxIdEnum;
    508          else stage=5;
    509    }
    510    if(stage==5){
    511               if (strcmp(name,"BasalforcingsPicoOverturningCoeff")==0) return BasalforcingsPicoOverturningCoeffEnum;
     528              else if (strcmp(name,"BasalforcingsPicoOverturningCoeff")==0) return BasalforcingsPicoOverturningCoeffEnum;
    512529              else if (strcmp(name,"BasalforcingsPicoSubShelfOceanOverturning")==0) return BasalforcingsPicoSubShelfOceanOverturningEnum;
    513530              else if (strcmp(name,"BasalforcingsPicoSubShelfOceanSalinity")==0) return BasalforcingsPicoSubShelfOceanSalinityEnum;
    … …  
    612629              else if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum;
    613630              else if (strcmp(name,"GiaMantleViscosity")==0) return GiaMantleViscosityEnum;
    614               else if (strcmp(name,"NGia")==0) return NGiaEnum;
     631         else stage=6;
     632   }
     633   if(stage==6){
     634              if (strcmp(name,"NGia")==0) return NGiaEnum;
    615635              else if (strcmp(name,"NGiaRate")==0) return NGiaRateEnum;
    616636              else if (strcmp(name,"UGia")==0) return UGiaEnum;
    … …  
    629649              else if (strcmp(name,"HydrologydcEplThicknessTransient")==0) return HydrologydcEplThicknessTransientEnum;
    630650              else if (strcmp(name,"HydrologydcMaskEplactiveElt")==0) return HydrologydcMaskEplactiveEltEnum;
    631          else stage=6;
    632    }
    633    if(stage==6){
    634               if (strcmp(name,"HydrologydcMaskEplactiveNode")==0) return HydrologydcMaskEplactiveNodeEnum;
     651              else if (strcmp(name,"HydrologydcMaskEplactiveNode")==0) return HydrologydcMaskEplactiveNodeEnum;
    635652              else if (strcmp(name,"HydrologydcMaskThawedElt")==0) return HydrologydcMaskThawedEltEnum;
    636653              else if (strcmp(name,"HydrologydcMaskThawedNode")==0) return HydrologydcMaskThawedNodeEnum;
    … …  
    705722              else if (strcmp(name,"SealevelNEsaRate")==0) return SealevelNEsaRateEnum;
    706723              else if (strcmp(name,"SealevelRSL")==0) return SealevelRSLEnum;
     724              else if (strcmp(name,"Bslr")==0) return BslrEnum;
     725              else if (strcmp(name,"BslrIce")==0) return BslrIceEnum;
     726              else if (strcmp(name,"BslrHydro")==0) return BslrHydroEnum;
     727              else if (strcmp(name,"BslrRate")==0) return BslrRateEnum;
     728              else if (strcmp(name,"Gmtslr")==0) return GmtslrEnum;
    707729              else if (strcmp(name,"SealevelRSLEustatic")==0) return SealevelRSLEustaticEnum;
    708730              else if (strcmp(name,"SealevelRSLEustaticRate")==0) return SealevelRSLEustaticRateEnum;
    … …  
    730752              else if (strcmp(name,"SigmaNN")==0) return SigmaNNEnum;
    731753              else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum;
    732               else if (strcmp(name,"SmbA")==0) return SmbAEnum;
     754         else stage=7;
     755   }
     756   if(stage==7){
     757              if (strcmp(name,"SmbA")==0) return SmbAEnum;
    733758              else if (strcmp(name,"SmbAValue")==0) return SmbAValueEnum;
    734759              else if (strcmp(name,"SmbAccumulation")==0) return SmbAccumulationEnum;
    … …  
    752777              else if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum;
    753778              else if (strcmp(name,"SmbDswrf")==0) return SmbDswrfEnum;
    754          else stage=7;
    755    }
    756    if(stage==7){
    757               if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum;
     779              else if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum;
    758780              else if (strcmp(name,"SmbDz")==0) return SmbDzEnum;
    759781              else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum;
    … …  
    853875              else if (strcmp(name,"SurfaceOld")==0) return SurfaceOldEnum;
    854876              else if (strcmp(name,"SurfaceLogVelMisfit")==0) return SurfaceLogVelMisfitEnum;
    855               else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum;
     877         else stage=8;
     878   }
     879   if(stage==8){
     880              if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum;
    856881              else if (strcmp(name,"SurfaceObservation")==0) return SurfaceObservationEnum;
    857882              else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum;
    … …  
    875900              else if (strcmp(name,"Vx")==0) return VxEnum;
    876901              else if (strcmp(name,"VxMesh")==0) return VxMeshEnum;
    877          else stage=8;
    878    }
    879    if(stage==8){
    880               if (strcmp(name,"VxObs")==0) return VxObsEnum;
     902              else if (strcmp(name,"VxObs")==0) return VxObsEnum;
    881903              else if (strcmp(name,"VyAverage")==0) return VyAverageEnum;
    882904              else if (strcmp(name,"Vy")==0) return VyEnum;
    … …  
    976998              else if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum;
    977999              else if (strcmp(name,"Outputdefinition83")==0) return Outputdefinition83Enum;
    978               else if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum;
    9791004              else if (strcmp(name,"Outputdefinition85")==0) return Outputdefinition85Enum;
    9801005              else if (strcmp(name,"Outputdefinition86")==0) return Outputdefinition86Enum;
    … …  
    9981023              else if (strcmp(name,"Absolute")==0) return AbsoluteEnum;
    9991024              else if (strcmp(name,"AdaptiveTimestepping")==0) return AdaptiveTimesteppingEnum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"AdjointBalancethickness2Analysis")==0) return AdjointBalancethickness2AnalysisEnum;
     1025              else if (strcmp(name,"AdjointBalancethickness2Analysis")==0) return AdjointBalancethickness2AnalysisEnum;
    10041026              else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum;
    10051027              else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum;
    … …  
    10991121              else if (strcmp(name,"FreeSurfaceBaseAnalysis")==0) return FreeSurfaceBaseAnalysisEnum;
    11001122              else if (strcmp(name,"FreeSurfaceTopAnalysis")==0) return FreeSurfaceTopAnalysisEnum;
    1101               else if (strcmp(name,"FrontalForcingsDefault")==0) return FrontalForcingsDefaultEnum;
     1123         else stage=10;
     1124   }
     1125   if(stage==10){
     1126              if (strcmp(name,"FrontalForcingsDefault")==0) return FrontalForcingsDefaultEnum;
    11021127              else if (strcmp(name,"FrontalForcingsRignot")==0) return FrontalForcingsRignotEnum;
    11031128              else if (strcmp(name,"Fset")==0) return FsetEnum;
    … …  
    11211146              else if (strcmp(name,"GroundingOnly")==0) return GroundingOnlyEnum;
    11221147              else if (strcmp(name,"GroundinglineMassFlux")==0) return GroundinglineMassFluxEnum;
    1123          else stage=10;
    1124    }
    1125    if(stage==10){
    1126               if (strcmp(name,"Gset")==0) return GsetEnum;
     1148              else if (strcmp(name,"Gset")==0) return GsetEnum;
    11271149              else if (strcmp(name,"Gsl")==0) return GslEnum;
    11281150              else if (strcmp(name,"HOApproximation")==0) return HOApproximationEnum;
    … …  
    12221244              else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum;
    12231245              else if (strcmp(name,"Mpi")==0) return MpiEnum;
    1224               else if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum;
     1246         else stage=11;
     1247   }
     1248   if(stage==11){
     1249              if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum;
    12251250              else if (strcmp(name,"Mumps")==0) return MumpsEnum;
    12261251              else if (strcmp(name,"NoFrictionOnPartiallyFloating")==0) return NoFrictionOnPartiallyFloatingEnum;
    … …  
    12441269              else if (strcmp(name,"P0DG")==0) return P0DGEnum;
    12451270              else if (strcmp(name,"P1DG")==0) return P1DGEnum;
    1246          else stage=11;
    1247    }
    1248    if(stage==11){
    1249               if (strcmp(name,"P1P1")==0) return P1P1Enum;
     1271              else if (strcmp(name,"P1P1")==0) return P1P1Enum;
    12501272              else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum;
    12511273              else if (strcmp(name,"P1bubble")==0) return P1bubbleEnum;
    … …  
    13141336              else if (strcmp(name,"SpcTransient")==0) return SpcTransientEnum;
    13151337              else if (strcmp(name,"Sset")==0) return SsetEnum;
     1338              else if (strcmp(name,"StatisticsSolution")==0) return StatisticsSolutionEnum;
    13161339              else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
    13171340              else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
    … …  
    13441367              else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum;
    13451368              else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum;
    1346               else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum;
     1369         else stage=12;
     1370   }
     1371   if(stage==12){
     1372              if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum;
    13471373              else if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
    13481374              else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
    … …  
    13671393              else if (strcmp(name,"CalvingdevCoeff")==0) return CalvingdevCoeffEnum;
    13681394              else if (strcmp(name,"DeviatoricStress")==0) return DeviatoricStressEnum;
    1369          else stage=12;
    1370    }
    1371    if(stage==12){
    1372               if (strcmp(name,"EtaAbsGradient")==0) return EtaAbsGradientEnum;
     1395              else if (strcmp(name,"EtaAbsGradient")==0) return EtaAbsGradientEnum;
    13731396              else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
    13741397              else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum;

  • issm/trunk-jpl/src/c/shared/Enum/Synchronize.sh

    r25556 r25627  
    11#!/bin/bash
    2 #Synchronize EnumToStringx.cpp and StringToEnumx.cpp and matlab Enums
    3 
    4 #Get all lines of EnumDefinitions2.h which hold Enum | remove all commas > put everything in file temp
     2################################################################################
     3# Synchronize EnumToStringx.cpp and StringToEnumx.cpp and MATLAB Enums
     4#
     5# Get all lines of EnumDefinitions.h which hold Enum | remove all commas > put everything in file temp
     6#
     7# NOTE: Even when run from this directory, ISSM_DIR must be defined correctly.
     8#
    59cat EnumDefinitions.h | grep -e "[0-9]Enum," -e "[a-zA-Z]Enum," -e "MaximumNumberOfDefinitionsEnum" | grep -v include | sed -e "s/,/ /g" | awk '{print $1}' > temp
    610

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

    r25090 r25627  
    1313                method                      = struct();
    1414                params                      = struct();
     15                statistics                  = qmustatistics();
    1516                results                     = struct();
    1617                numberofresponses           = 0;
    … …  
    225226                                return;
    226227                        end
     228                        WriteData(fid,prefix,'data',self.method.params.samples,'name','md.qmu.method.params.samples','format','Integer');
    227229                        WriteData(fid,prefix,'object',self,'fieldname','numberofresponses','format','Integer');
    228230                        WriteData(fid,prefix,'object',self,'fieldname','variabledescriptors','format','StringArray');
    … …  
    240242                        end
    241243                        WriteData(fid,prefix,'data',flag,'name','md.qmu.mass_flux_segments_present','format','Boolean');
     244                        self.statistics.marshall(prefix,md,fid);
     245
    242246                end % }}}
    243247                function savemodeljs(self,fid,modelname) % {{{

  • issm/trunk-jpl/src/m/contrib/larour/glacier_inventory.m

    r24880 r25627  
    149149                        errornotfound=getfieldvalue(options,'errornotfound',1);
    150150                        plotr=getfieldvalue(options,'plot',0);
     151                        plotr=1;
    151152
    152153                        %The way we run this is through the O2 zones defined in boxes. We go through
    … …  
    203204                                        switch i,
    204205                                                case 4, radius=40;
     206                                                case 8, radius=60;
    205207                                                case 12, radius=25;
     208                                                case 19, radius=60;
     209                                                case 32, radius=60;
    206210                                                case 33, radius=5;
    207211                                                case 41, radius=75;
    208212                                                case 42, radius=45;
     213                                                case 61, radius=66;
    209214                                                case 68, radius=10;
    210215                                                case 82, radius=30;

  • issm/trunk-jpl/src/m/contrib/larour/oceanmip.m

    r25326 r25627  
    4646                                        pos=find(diff(time)<0);
    4747                                        if isempty(pos),
    48                                                 pos=(length(time)-12*100+1):length(time);
     48                                                %pos=(length(time)-12*100+1):length(time);
     49                                                pos=1:length(time);
    4950                                        else
    5051                                                pos=[(pos+1):length(time)];
    … …  
    7576                                                zostogam(year)=mean(zostoga(i-11:i));
    7677                                        end
     78                                        %control against 2006:
     79                                        zostogam=zostogam-zostogam(1);
    7780                                        self.zostoga{end+1}=zostogam; clear zostoga;
    7881
    … …  
    109112                                disp(['interpolating model ' self.model{i} ' onto model mesh']);
    110113
     114                                %If we have 182 cells in long, trim by 1 on each side:
     115                                if size(self.pbo{i},1)==182,
     116                                        self.pbo{i}=self.pbo{i}(2:181,:,:);
     117                                        self.zos{i}=self.zos{i}(2:181,:,:);
     118                                        self.long{i}=self.long{i}(2:181,:,:);
     119                                        self.lat{i}=self.lat{i}(2:181,:,:);
     120                                end
     121
     122
    111123                                %triangulation:
    112                                 long=double(self.long{i});  long=long(:);
     124                                long=double(self.long{i});  long=long(:);
     125                                pos=find(long<0); long(pos)=long(pos)+360;
    113126                                lat=double(self.lat{i}); lat=lat(:);
    114127                                [newl,uniqpos]=unique([lat,long],'rows','stable');
    … …  
    122135                                ind=find(areas<1e-8); index(ind,:)=[];
    123136
     137                                %fix if we have orphans
     138                                [index long lat dummy newpos]=FixMesh(index,long,lat,1:length(long));
     139
    124140                                time=self.time{i};
    125141                                %retrieve fields:
    … …  
    133149
    134150                                parfor j=1:length(time),
     151                                %for j=1:length(time),
    135152                                        if mod(j,10)==0,
    136153                                                s=sprintf('   progress: %.2g ',j/length(time)*100);
    … …  
    138155                                        end
    139156
    140                                         pbo=omip_pbo(:,:,j); pbo=pbo(:); pbo=pbo(uniqpos);
     157                                        pbo=omip_pbo(:,:,j); pbo=pbo(:); pbo=pbo(uniqpos); 
    141158                                        zos=omip_zos(:,:,j); zos=zos(:); zos=zos(uniqpos);
    142159
    143                                         mesh_pbo(:,j)=InterpFromMeshToMesh2d(index,long,lat,pbo,meshlong,meshlat);
    144                                         mesh_zos(:,j)=InterpFromMeshToMesh2d(index,long,lat,zos,meshlong,meshlat);
     160                                        pboj= InterpFromMeshToMesh2d(index,long,lat,pbo(newpos),meshlong,meshlat);
     161                                        pos=find(abs(pboj)>1e4); pboj(pos)=0;
     162                                        mesh_pbo(:,j)=pboj;
     163
     164                                        zosj=InterpFromMeshToMesh2d(index,long,lat,zos(newpos),meshlong,meshlat);
     165                                        pos=find(abs(zosj)>1e5); zosj(pos)=0;
     166                                        mesh_zos(:,j)=zosj;
    145167                                end
    146168                                self.mesh_pbo{end+1}=mesh_pbo;
    … …  
    200222                                                pbo=self.mesh_pbo{i}; pbo=pbo/1000; %in meters
    201223                                        end
    202                                         time=self.time{i};
    203                                         array=[pbo;time];
     224                                        array=pbo;
    204225                                        break;
    205226                                end

  • issm/trunk-jpl/src/m/plot/plot_coastlines.m

    r25325 r25627  
    22
    33%define coastline: {{{
    4 coast=[-83.83 -180 ;...
     4coast=[-90 -180; ...
     5        -83.83 -180 ;...
    56-84.33 -178 ;...
    67-84.5 -174 ;...
    … …  
    614615-83.5 176 ;...
    615616-83.83 180 ;...
     617-85 180 ;...
     618-87 180 ;...
     619-90 180 ;...
    616620NaN NaN ;...
    617621-77.58 166.33 ;...
    … …  
    9866987019.77 -156.05 ;...
    9867987119.95 -155.87 ;...
    9868 20.27 -155.88 ];
     987220.27 -155.88 ;...
     9873NaN NaN];
    98699874
    9870 coastlat=coast(:,1);
    9871 coastlon=coast(:,2);
     9875coastlat=[coast(:,1); coast(:,1)];
     9876coastlon=[coast(:,2); coast(:,2)-360];
    98729877
    98739878%}}}
    … …  
    99029907                p=polyshape(coastlon,coastlat);
    99039908                plot(p,'FaceColor','w','FaceAlpha',1);
     9909                if strcmpi(getfieldvalue(options,'coordcent','atlantic'),'pacific'),
     9910                        xlim(getfieldvalue(options,'xlim',[-360 0]));
     9911                else
     9912                        xlim(getfieldvalue(options,'xlim',[-180 180]));
     9913                end
    99049914                %p=plot(coastlon,coastlat,'k-');
    99059915        end

  • issm/trunk-jpl/src/m/plot/processdata.m

    r25622 r25627  
    4242end
    4343
     44%special case for coord latlong:
     45if strcmpi(getfieldvalue(options,'coord','xy'),'latlon') | strcmpi(getfieldvalue(options,'coord','xy'),'latlong'),
     46        [data datatype] = processdatalatlong(md,data,options);
     47        return;
     48end
     49
    4450%needed later on
    4551if isprop(md.mesh,'numberofvertices2d'),

  • issm/trunk-jpl/src/m/plot/processmesh.m

    r25621 r25627  
    2424if strcmp(domaintype(md.mesh),'3Dsurface'),
    2525        [x y z elements is2d isplanet] = processmesh(md.mesh,options);
    26         if strcmpi(getfieldvalue(options,'coord','xy'),'latlon'),
    27                 x=md.mesh.long;
    28                 y=md.mesh.lat;
     26        if strcmpi(getfieldvalue(options,'coord','xy'),'latlon') | strcmpi(getfieldvalue(options,'coord','xy'),'latlong'),
     27                x0=md.mesh.long;
     28                y0=md.mesh.lat;
     29                %add row at lat=90 and lat=-90
     30                add=[(-180:.1:-1e-5)';(1e-5:.1:180)'];
     31                nadd=length(add);
     32                xextra=[add;add];
     33                yextra=[90*ones(nadd,1); -90*ones(nadd,1)];
     34                x=[x0;xextra];
     35                y=[y0;yextra];
     36
     37                if strcmpi(getfieldvalue(options,'coordcent','atlantic'),'pacific'),
     38                        pos=find(x>0);  x(pos)=-360+x(pos);
     39                end
    2940                elements=delaunay(x,y);
    30                 z=md.mesh.lat; z(:)=0;
     41                z=x; z(:)=0;
    3142        end
    3243        return;
    … …  
    4253else
    4354        elements=md.mesh.elements;
    44         if ~strcmpi(getfieldvalue(options,'coord','xy'),'latlon') ,
     55        if ~strcmpi(getfieldvalue(options,'coord','xy'),'latlon') &  ~strcmpi(getfieldvalue(options,'coord','xy'),'latlong') ,
    4556                x=md.mesh.x;
    4657                if isprop(md.mesh,'x2d'), x2d=md.mesh.x2d; end
    … …  
    5061                x=md.mesh.long;
    5162                y=md.mesh.lat;
     63                if strcmpi(getfieldvalue(options,'coordcent','atlantic'),'pacific'),
     64                        pos=find(x>0);  x(pos)-360+x(pos);
     65                end
    5266        end
    5367end

  • issm/trunk-jpl/src/m/plot/subplotmodel.m

    r23108 r25627  
    2525ymin   = 1-vmargin(2)-height;
    2626
     27box=getfieldvalue(options,'box','off');
     28if strcmpi(box,'on'),
     29        visible='on';
     30else
     31        visible='off';
     32end
     33
    2734for i = 1:nlines
    2835        xmin = hmargin(1);
    … …  
    3037                if(((i-1)*ncols+j)==num)
    3138                        ha = axes('Units','normalized', ...
    32                                 'Position',[xmin ymin width height],'XTickLabel','','YTickLabel','','Visible','off');
     39                                'Position',[xmin ymin width height],'XTickLabel','','YTickLabel','',...
     40                                'Visible',visible,'box',box);
    3341                        return
    3442                end

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

    r25163 r25627  
    3636end
    3737
    38 if md.qmu.output,
     38if md.qmu.output & strcmpi(md.qmu.statistics.method(1).name,'None'),
    3939        if strcmpi(md.qmu.method.method,'nond_sampling'),
    4040                dakotaresults.modelresults={};
    … …  
    4646                end
    4747        end
     48end
     49if ~strcmpi(md.qmu.statistics.method(1).name,'None'),
     50        md.qmu.isdakota=0;
     51        md=loadresultsfromdisk(md,[md.miscellaneous.name,'.stats']);
     52        md.qmu.isdakota=1;
    4853end
    4954

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

    r24541 r25627  
    3030                end
    3131        end
    32         if md.qmu.output,
     32        if md.qmu.output & strcmpi(md.qmu.statistics.method(1).name,'None'),
    3333                if strcmpi(md.qmu.method.method,'nond_sampling'),
    3434                        for i=1:md.qmu.method.params.samples
    … …  
    3636                        end
    3737                end
     38        end
     39        if ~strcmpi(md.qmu.statistics.method(1).name,'None'),
     40                filelist{end+1}=[md.miscellaneous.name '.stats'];
    3841        end
    3942else

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

    r24538 r25627  
    3535                error(['No result found in binary file ' filename '. Check for solution crash.']);
    3636        end
     37        if isempty(structure(1).SolutionType),
     38                if ~isempty(structure(end).SolutionType),
     39                        structure(1).SolutionType=structure(end).SolutionType;
     40                else
     41                        warning(['Cannot find a solution type in the results! Ascribing one: ''NoneSolution''.']);
     42                        structure(1).SolutionType='NoneSolution';
     43                end
     44        end
    3745        md.results.(structure(1).SolutionType)=structure;
    3846
    … …  
    4048        md.private.solution=structure(1).SolutionType;
    4149
    42         %read log files onto  fields
     50        %read log files onto fields
    4351        if exist([md.miscellaneous.name '.errlog'],'file'),
    4452                md.results.(structure(1).SolutionType)(1).errlog=char(textread([md.miscellaneous.name '.errlog'],'%s','delimiter','\n'));

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

    r25561 r25627  
    55else
    66        results=parseresultsfromdiskioserial(md,filename);
    7 end
    8 
     7        %results=parseresultsfromdiskioserialsequential(md,filename);
     8end
     9
     10function results=parseresultsfromdiskioserialsequential(md,filename) % {{{
     11
     12%Open file
     13fid=fopen(filename,'rb');
     14if(fid==-1),
     15        error(['loadresultsfromdisk error message: could not open ',filename,' for binary reading']);
     16end
     17
     18%first pass to figure out the steps we have:
     19steps=[];
     20while  1,
     21        result  = ReadDataDimensions(fid);
     22        if isempty(result),
     23                break;
     24        end
     25        if result.step~=-9999,
     26                steps=[steps result.step];
     27        end
     28end
     29
     30steps=unique(steps);
     31
     32%create structure:
     33results=struct('step',num2cell(steps));
     34
     35%second pass to fill the steps we have:
     36fseek(fid,0,-1); %rewind
     37while  1,
     38        result  = ReadData(fid,md);
     39        if isempty(result),
     40                break;
     41        end
     42        if result.step==-9999,
     43                result.step=1;
     44                result.time=0;
     45        end
     46        %find where we are putting this step:
     47        ind=find(steps==result.step);
     48        if isempty(ind),
     49                error('could not find a step in our pre-structure! Something is very off!');
     50        end
     51
     52        %plug:
     53        results(ind).time=result.time;
     54        results(ind).(result.fieldname)=result.field;
     55end
     56fclose(fid);
     57% }}}
    958function results=parseresultsfromdiskioserial(md,filename) % {{{
    1059

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

    r25516 r25627  
    394394
    395395%eustatic run:
    396 md.solidearth.settings.rigid=0; md.solidearth.settings.elastic=0;md.solidearth.settings.rotation=0;
     396md.solidearth.settings.rigid=0;
     397md.solidearth.settings.elastic=0;
     398md.solidearth.settings.rotation=0;
    397399md.solidearth.requested_outputs= {'default',...
    398             'SurfaceloadIceThicknessChange','Sealevel','SealevelRSLRate','SealevelriseCumDeltathickness',...
    399                     'SealevelNEsaRate', 'SealevelUEsaRate', 'NGiaRate', 'UGiaRate','SealevelEustaticMask','SealevelEustaticOceanMask'};
     400        'SurfaceloadIceThicknessChange','Sealevel','SealevelRSLRate','SealevelriseCumDeltathickness',...
     401        'SealevelNEsaRate', 'SealevelUEsaRate', 'NGiaRate', 'UGiaRate','SealevelEustaticMask','SealevelEustaticOceanMask'};
    400402md=solve(md,'Sealevelrise');
    401403Seustatic=md.results.SealevelriseSolution.Sealevel;
    402404
    403405%eustatic + rigid run:
    404 md.solidearth.settings.rigid=1; md.solidearth.settings.elastic=0;md.solidearth.settings.rotation=0;
     406md.solidearth.settings.rigid=1;
     407md.solidearth.settings.elastic=0;
     408md.solidearth.settings.rotation=0;
    405409md=solve(md,'Sealevelrise');
    406410Srigid=md.results.SealevelriseSolution.Sealevel;
    407411
    408412%eustatic + rigid + elastic run:
    409 md.solidearth.settings.rigid=1; md.solidearth.settings.elastic=1;md.solidearth.settings.rotation=0;
     413md.solidearth.settings.rigid=1;
     414md.solidearth.settings.elastic=1;
     415md.solidearth.settings.rotation=0;
    410416md=solve(md,'Sealevelrise');
    411417Selastic=md.results.SealevelriseSolution.Sealevel;
    412418
    413419%eustatic + rigid + elastic + rotation run:
    414 md.solidearth.settings.rigid=1; md.solidearth.settings.elastic=1; md.solidearth.settings.rotation=1;
     420md.solidearth.settings.rigid=1;
     421md.solidearth.settings.elastic=1;
     422md.solidearth.settings.rotation=1;
    415423md=solve(md,'Sealevelrise');
    416424Srotation=md.results.SealevelriseSolution.Sealevel;

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

    r25168 r25627  
    7575% uncomment following 2 lines for
    7676md=solve(md,'Sealevelrise');
    77 eus=md.results.SealevelriseSolution.SealevelRSLEustatic;
     77eus=md.results.SealevelriseSolution.Bslr;
    7878slr=md.results.SealevelriseSolution.Sealevel;
    7979moixz=md.results.SealevelriseSolution.SealevelInertiaTensorXZ;
Note: See TracChangeset for help on using the changeset viewer.